##// END OF EJS Templates
ux: adjust email_or_none so that it does not swap emails
lisaq -
r409:1a0e6c35 default
parent child Browse files
Show More
@@ -1,1888 +1,1886 b''
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2
2
3 # Copyright (C) 2010-2016 RhodeCode GmbH
3 # Copyright (C) 2010-2016 RhodeCode GmbH
4 #
4 #
5 # This program is free software: you can redistribute it and/or modify
5 # This program is free software: you can redistribute it and/or modify
6 # it under the terms of the GNU Affero General Public License, version 3
6 # it under the terms of the GNU Affero General Public License, version 3
7 # (only), as published by the Free Software Foundation.
7 # (only), as published by the Free Software Foundation.
8 #
8 #
9 # This program is distributed in the hope that it will be useful,
9 # This program is distributed in the hope that it will be useful,
10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 # GNU General Public License for more details.
12 # GNU General Public License for more details.
13 #
13 #
14 # You should have received a copy of the GNU Affero General Public License
14 # You should have received a copy of the GNU Affero General Public License
15 # along with this program. If not, see <http://www.gnu.org/licenses/>.
15 # along with this program. If not, see <http://www.gnu.org/licenses/>.
16 #
16 #
17 # This program is dual-licensed. If you wish to learn more about the
17 # This program is dual-licensed. If you wish to learn more about the
18 # RhodeCode Enterprise Edition, including its added features, Support services,
18 # RhodeCode Enterprise Edition, including its added features, Support services,
19 # and proprietary license terms, please see https://rhodecode.com/licenses/
19 # and proprietary license terms, please see https://rhodecode.com/licenses/
20
20
21 """
21 """
22 Helper functions
22 Helper functions
23
23
24 Consists of functions to typically be used within templates, but also
24 Consists of functions to typically be used within templates, but also
25 available to Controllers. This module is available to both as 'h'.
25 available to Controllers. This module is available to both as 'h'.
26 """
26 """
27
27
28 import random
28 import random
29 import hashlib
29 import hashlib
30 import StringIO
30 import StringIO
31 import urllib
31 import urllib
32 import math
32 import math
33 import logging
33 import logging
34 import re
34 import re
35 import urlparse
35 import urlparse
36 import time
36 import time
37 import string
37 import string
38 import hashlib
38 import hashlib
39 import pygments
39 import pygments
40
40
41 from datetime import datetime
41 from datetime import datetime
42 from functools import partial
42 from functools import partial
43 from pygments.formatters.html import HtmlFormatter
43 from pygments.formatters.html import HtmlFormatter
44 from pygments import highlight as code_highlight
44 from pygments import highlight as code_highlight
45 from pygments.lexers import (
45 from pygments.lexers import (
46 get_lexer_by_name, get_lexer_for_filename, get_lexer_for_mimetype)
46 get_lexer_by_name, get_lexer_for_filename, get_lexer_for_mimetype)
47 from pylons import url
47 from pylons import url
48 from pylons.i18n.translation import _, ungettext
48 from pylons.i18n.translation import _, ungettext
49 from pyramid.threadlocal import get_current_request
49 from pyramid.threadlocal import get_current_request
50
50
51 from webhelpers.html import literal, HTML, escape
51 from webhelpers.html import literal, HTML, escape
52 from webhelpers.html.tools import *
52 from webhelpers.html.tools import *
53 from webhelpers.html.builder import make_tag
53 from webhelpers.html.builder import make_tag
54 from webhelpers.html.tags import auto_discovery_link, checkbox, css_classes, \
54 from webhelpers.html.tags import auto_discovery_link, checkbox, css_classes, \
55 end_form, file, form as wh_form, hidden, image, javascript_link, link_to, \
55 end_form, file, form as wh_form, hidden, image, javascript_link, link_to, \
56 link_to_if, link_to_unless, ol, required_legend, select, stylesheet_link, \
56 link_to_if, link_to_unless, ol, required_legend, select, stylesheet_link, \
57 submit, text, password, textarea, title, ul, xml_declaration, radio
57 submit, text, password, textarea, title, ul, xml_declaration, radio
58 from webhelpers.html.tools import auto_link, button_to, highlight, \
58 from webhelpers.html.tools import auto_link, button_to, highlight, \
59 js_obfuscate, mail_to, strip_links, strip_tags, tag_re
59 js_obfuscate, mail_to, strip_links, strip_tags, tag_re
60 from webhelpers.pylonslib import Flash as _Flash
60 from webhelpers.pylonslib import Flash as _Flash
61 from webhelpers.text import chop_at, collapse, convert_accented_entities, \
61 from webhelpers.text import chop_at, collapse, convert_accented_entities, \
62 convert_misc_entities, lchop, plural, rchop, remove_formatting, \
62 convert_misc_entities, lchop, plural, rchop, remove_formatting, \
63 replace_whitespace, urlify, truncate, wrap_paragraphs
63 replace_whitespace, urlify, truncate, wrap_paragraphs
64 from webhelpers.date import time_ago_in_words
64 from webhelpers.date import time_ago_in_words
65 from webhelpers.paginate import Page as _Page
65 from webhelpers.paginate import Page as _Page
66 from webhelpers.html.tags import _set_input_attrs, _set_id_attr, \
66 from webhelpers.html.tags import _set_input_attrs, _set_id_attr, \
67 convert_boolean_attrs, NotGiven, _make_safe_id_component
67 convert_boolean_attrs, NotGiven, _make_safe_id_component
68 from webhelpers2.number import format_byte_size
68 from webhelpers2.number import format_byte_size
69
69
70 from rhodecode.lib.annotate import annotate_highlight
70 from rhodecode.lib.annotate import annotate_highlight
71 from rhodecode.lib.action_parser import action_parser
71 from rhodecode.lib.action_parser import action_parser
72 from rhodecode.lib.ext_json import json
72 from rhodecode.lib.ext_json import json
73 from rhodecode.lib.utils import repo_name_slug, get_custom_lexer
73 from rhodecode.lib.utils import repo_name_slug, get_custom_lexer
74 from rhodecode.lib.utils2 import str2bool, safe_unicode, safe_str, \
74 from rhodecode.lib.utils2 import str2bool, safe_unicode, safe_str, \
75 get_commit_safe, datetime_to_time, time_to_datetime, time_to_utcdatetime, \
75 get_commit_safe, datetime_to_time, time_to_datetime, time_to_utcdatetime, \
76 AttributeDict, safe_int, md5, md5_safe
76 AttributeDict, safe_int, md5, md5_safe
77 from rhodecode.lib.markup_renderer import MarkupRenderer
77 from rhodecode.lib.markup_renderer import MarkupRenderer
78 from rhodecode.lib.vcs.exceptions import CommitDoesNotExistError
78 from rhodecode.lib.vcs.exceptions import CommitDoesNotExistError
79 from rhodecode.lib.vcs.backends.base import BaseChangeset, EmptyCommit
79 from rhodecode.lib.vcs.backends.base import BaseChangeset, EmptyCommit
80 from rhodecode.config.conf import DATE_FORMAT, DATETIME_FORMAT
80 from rhodecode.config.conf import DATE_FORMAT, DATETIME_FORMAT
81 from rhodecode.model.changeset_status import ChangesetStatusModel
81 from rhodecode.model.changeset_status import ChangesetStatusModel
82 from rhodecode.model.db import Permission, User, Repository
82 from rhodecode.model.db import Permission, User, Repository
83 from rhodecode.model.repo_group import RepoGroupModel
83 from rhodecode.model.repo_group import RepoGroupModel
84 from rhodecode.model.settings import IssueTrackerSettingsModel
84 from rhodecode.model.settings import IssueTrackerSettingsModel
85
85
86 log = logging.getLogger(__name__)
86 log = logging.getLogger(__name__)
87
87
88 DEFAULT_USER = User.DEFAULT_USER
88 DEFAULT_USER = User.DEFAULT_USER
89 DEFAULT_USER_EMAIL = User.DEFAULT_USER_EMAIL
89 DEFAULT_USER_EMAIL = User.DEFAULT_USER_EMAIL
90
90
91
91
92 def html_escape(text, html_escape_table=None):
92 def html_escape(text, html_escape_table=None):
93 """Produce entities within text."""
93 """Produce entities within text."""
94 if not html_escape_table:
94 if not html_escape_table:
95 html_escape_table = {
95 html_escape_table = {
96 "&": "&amp;",
96 "&": "&amp;",
97 '"': "&quot;",
97 '"': "&quot;",
98 "'": "&apos;",
98 "'": "&apos;",
99 ">": "&gt;",
99 ">": "&gt;",
100 "<": "&lt;",
100 "<": "&lt;",
101 }
101 }
102 return "".join(html_escape_table.get(c, c) for c in text)
102 return "".join(html_escape_table.get(c, c) for c in text)
103
103
104
104
105 def chop_at_smart(s, sub, inclusive=False, suffix_if_chopped=None):
105 def chop_at_smart(s, sub, inclusive=False, suffix_if_chopped=None):
106 """
106 """
107 Truncate string ``s`` at the first occurrence of ``sub``.
107 Truncate string ``s`` at the first occurrence of ``sub``.
108
108
109 If ``inclusive`` is true, truncate just after ``sub`` rather than at it.
109 If ``inclusive`` is true, truncate just after ``sub`` rather than at it.
110 """
110 """
111 suffix_if_chopped = suffix_if_chopped or ''
111 suffix_if_chopped = suffix_if_chopped or ''
112 pos = s.find(sub)
112 pos = s.find(sub)
113 if pos == -1:
113 if pos == -1:
114 return s
114 return s
115
115
116 if inclusive:
116 if inclusive:
117 pos += len(sub)
117 pos += len(sub)
118
118
119 chopped = s[:pos]
119 chopped = s[:pos]
120 left = s[pos:].strip()
120 left = s[pos:].strip()
121
121
122 if left and suffix_if_chopped:
122 if left and suffix_if_chopped:
123 chopped += suffix_if_chopped
123 chopped += suffix_if_chopped
124
124
125 return chopped
125 return chopped
126
126
127
127
128 def shorter(text, size=20):
128 def shorter(text, size=20):
129 postfix = '...'
129 postfix = '...'
130 if len(text) > size:
130 if len(text) > size:
131 return text[:size - len(postfix)] + postfix
131 return text[:size - len(postfix)] + postfix
132 return text
132 return text
133
133
134
134
135 def _reset(name, value=None, id=NotGiven, type="reset", **attrs):
135 def _reset(name, value=None, id=NotGiven, type="reset", **attrs):
136 """
136 """
137 Reset button
137 Reset button
138 """
138 """
139 _set_input_attrs(attrs, type, name, value)
139 _set_input_attrs(attrs, type, name, value)
140 _set_id_attr(attrs, id, name)
140 _set_id_attr(attrs, id, name)
141 convert_boolean_attrs(attrs, ["disabled"])
141 convert_boolean_attrs(attrs, ["disabled"])
142 return HTML.input(**attrs)
142 return HTML.input(**attrs)
143
143
144 reset = _reset
144 reset = _reset
145 safeid = _make_safe_id_component
145 safeid = _make_safe_id_component
146
146
147
147
148 def branding(name, length=40):
148 def branding(name, length=40):
149 return truncate(name, length, indicator="")
149 return truncate(name, length, indicator="")
150
150
151
151
152 def FID(raw_id, path):
152 def FID(raw_id, path):
153 """
153 """
154 Creates a unique ID for filenode based on it's hash of path and commit
154 Creates a unique ID for filenode based on it's hash of path and commit
155 it's safe to use in urls
155 it's safe to use in urls
156
156
157 :param raw_id:
157 :param raw_id:
158 :param path:
158 :param path:
159 """
159 """
160
160
161 return 'c-%s-%s' % (short_id(raw_id), md5_safe(path)[:12])
161 return 'c-%s-%s' % (short_id(raw_id), md5_safe(path)[:12])
162
162
163
163
164 class _GetError(object):
164 class _GetError(object):
165 """Get error from form_errors, and represent it as span wrapped error
165 """Get error from form_errors, and represent it as span wrapped error
166 message
166 message
167
167
168 :param field_name: field to fetch errors for
168 :param field_name: field to fetch errors for
169 :param form_errors: form errors dict
169 :param form_errors: form errors dict
170 """
170 """
171
171
172 def __call__(self, field_name, form_errors):
172 def __call__(self, field_name, form_errors):
173 tmpl = """<span class="error_msg">%s</span>"""
173 tmpl = """<span class="error_msg">%s</span>"""
174 if form_errors and field_name in form_errors:
174 if form_errors and field_name in form_errors:
175 return literal(tmpl % form_errors.get(field_name))
175 return literal(tmpl % form_errors.get(field_name))
176
176
177 get_error = _GetError()
177 get_error = _GetError()
178
178
179
179
180 class _ToolTip(object):
180 class _ToolTip(object):
181
181
182 def __call__(self, tooltip_title, trim_at=50):
182 def __call__(self, tooltip_title, trim_at=50):
183 """
183 """
184 Special function just to wrap our text into nice formatted
184 Special function just to wrap our text into nice formatted
185 autowrapped text
185 autowrapped text
186
186
187 :param tooltip_title:
187 :param tooltip_title:
188 """
188 """
189 tooltip_title = escape(tooltip_title)
189 tooltip_title = escape(tooltip_title)
190 tooltip_title = tooltip_title.replace('<', '&lt;').replace('>', '&gt;')
190 tooltip_title = tooltip_title.replace('<', '&lt;').replace('>', '&gt;')
191 return tooltip_title
191 return tooltip_title
192 tooltip = _ToolTip()
192 tooltip = _ToolTip()
193
193
194
194
195 def files_breadcrumbs(repo_name, commit_id, file_path):
195 def files_breadcrumbs(repo_name, commit_id, file_path):
196 if isinstance(file_path, str):
196 if isinstance(file_path, str):
197 file_path = safe_unicode(file_path)
197 file_path = safe_unicode(file_path)
198
198
199 # TODO: johbo: Is this always a url like path, or is this operating
199 # TODO: johbo: Is this always a url like path, or is this operating
200 # system dependent?
200 # system dependent?
201 path_segments = file_path.split('/')
201 path_segments = file_path.split('/')
202
202
203 repo_name_html = escape(repo_name)
203 repo_name_html = escape(repo_name)
204 if len(path_segments) == 1 and path_segments[0] == '':
204 if len(path_segments) == 1 and path_segments[0] == '':
205 url_segments = [repo_name_html]
205 url_segments = [repo_name_html]
206 else:
206 else:
207 url_segments = [
207 url_segments = [
208 link_to(
208 link_to(
209 repo_name_html,
209 repo_name_html,
210 url('files_home',
210 url('files_home',
211 repo_name=repo_name,
211 repo_name=repo_name,
212 revision=commit_id,
212 revision=commit_id,
213 f_path=''),
213 f_path=''),
214 class_='pjax-link')]
214 class_='pjax-link')]
215
215
216 last_cnt = len(path_segments) - 1
216 last_cnt = len(path_segments) - 1
217 for cnt, segment in enumerate(path_segments):
217 for cnt, segment in enumerate(path_segments):
218 if not segment:
218 if not segment:
219 continue
219 continue
220 segment_html = escape(segment)
220 segment_html = escape(segment)
221
221
222 if cnt != last_cnt:
222 if cnt != last_cnt:
223 url_segments.append(
223 url_segments.append(
224 link_to(
224 link_to(
225 segment_html,
225 segment_html,
226 url('files_home',
226 url('files_home',
227 repo_name=repo_name,
227 repo_name=repo_name,
228 revision=commit_id,
228 revision=commit_id,
229 f_path='/'.join(path_segments[:cnt + 1])),
229 f_path='/'.join(path_segments[:cnt + 1])),
230 class_='pjax-link'))
230 class_='pjax-link'))
231 else:
231 else:
232 url_segments.append(segment_html)
232 url_segments.append(segment_html)
233
233
234 return literal('/'.join(url_segments))
234 return literal('/'.join(url_segments))
235
235
236
236
237 class CodeHtmlFormatter(HtmlFormatter):
237 class CodeHtmlFormatter(HtmlFormatter):
238 """
238 """
239 My code Html Formatter for source codes
239 My code Html Formatter for source codes
240 """
240 """
241
241
242 def wrap(self, source, outfile):
242 def wrap(self, source, outfile):
243 return self._wrap_div(self._wrap_pre(self._wrap_code(source)))
243 return self._wrap_div(self._wrap_pre(self._wrap_code(source)))
244
244
245 def _wrap_code(self, source):
245 def _wrap_code(self, source):
246 for cnt, it in enumerate(source):
246 for cnt, it in enumerate(source):
247 i, t = it
247 i, t = it
248 t = '<div id="L%s">%s</div>' % (cnt + 1, t)
248 t = '<div id="L%s">%s</div>' % (cnt + 1, t)
249 yield i, t
249 yield i, t
250
250
251 def _wrap_tablelinenos(self, inner):
251 def _wrap_tablelinenos(self, inner):
252 dummyoutfile = StringIO.StringIO()
252 dummyoutfile = StringIO.StringIO()
253 lncount = 0
253 lncount = 0
254 for t, line in inner:
254 for t, line in inner:
255 if t:
255 if t:
256 lncount += 1
256 lncount += 1
257 dummyoutfile.write(line)
257 dummyoutfile.write(line)
258
258
259 fl = self.linenostart
259 fl = self.linenostart
260 mw = len(str(lncount + fl - 1))
260 mw = len(str(lncount + fl - 1))
261 sp = self.linenospecial
261 sp = self.linenospecial
262 st = self.linenostep
262 st = self.linenostep
263 la = self.lineanchors
263 la = self.lineanchors
264 aln = self.anchorlinenos
264 aln = self.anchorlinenos
265 nocls = self.noclasses
265 nocls = self.noclasses
266 if sp:
266 if sp:
267 lines = []
267 lines = []
268
268
269 for i in range(fl, fl + lncount):
269 for i in range(fl, fl + lncount):
270 if i % st == 0:
270 if i % st == 0:
271 if i % sp == 0:
271 if i % sp == 0:
272 if aln:
272 if aln:
273 lines.append('<a href="#%s%d" class="special">%*d</a>' %
273 lines.append('<a href="#%s%d" class="special">%*d</a>' %
274 (la, i, mw, i))
274 (la, i, mw, i))
275 else:
275 else:
276 lines.append('<span class="special">%*d</span>' % (mw, i))
276 lines.append('<span class="special">%*d</span>' % (mw, i))
277 else:
277 else:
278 if aln:
278 if aln:
279 lines.append('<a href="#%s%d">%*d</a>' % (la, i, mw, i))
279 lines.append('<a href="#%s%d">%*d</a>' % (la, i, mw, i))
280 else:
280 else:
281 lines.append('%*d' % (mw, i))
281 lines.append('%*d' % (mw, i))
282 else:
282 else:
283 lines.append('')
283 lines.append('')
284 ls = '\n'.join(lines)
284 ls = '\n'.join(lines)
285 else:
285 else:
286 lines = []
286 lines = []
287 for i in range(fl, fl + lncount):
287 for i in range(fl, fl + lncount):
288 if i % st == 0:
288 if i % st == 0:
289 if aln:
289 if aln:
290 lines.append('<a href="#%s%d">%*d</a>' % (la, i, mw, i))
290 lines.append('<a href="#%s%d">%*d</a>' % (la, i, mw, i))
291 else:
291 else:
292 lines.append('%*d' % (mw, i))
292 lines.append('%*d' % (mw, i))
293 else:
293 else:
294 lines.append('')
294 lines.append('')
295 ls = '\n'.join(lines)
295 ls = '\n'.join(lines)
296
296
297 # in case you wonder about the seemingly redundant <div> here: since the
297 # in case you wonder about the seemingly redundant <div> here: since the
298 # content in the other cell also is wrapped in a div, some browsers in
298 # content in the other cell also is wrapped in a div, some browsers in
299 # some configurations seem to mess up the formatting...
299 # some configurations seem to mess up the formatting...
300 if nocls:
300 if nocls:
301 yield 0, ('<table class="%stable">' % self.cssclass +
301 yield 0, ('<table class="%stable">' % self.cssclass +
302 '<tr><td><div class="linenodiv" '
302 '<tr><td><div class="linenodiv" '
303 'style="background-color: #f0f0f0; padding-right: 10px">'
303 'style="background-color: #f0f0f0; padding-right: 10px">'
304 '<pre style="line-height: 125%">' +
304 '<pre style="line-height: 125%">' +
305 ls + '</pre></div></td><td id="hlcode" class="code">')
305 ls + '</pre></div></td><td id="hlcode" class="code">')
306 else:
306 else:
307 yield 0, ('<table class="%stable">' % self.cssclass +
307 yield 0, ('<table class="%stable">' % self.cssclass +
308 '<tr><td class="linenos"><div class="linenodiv"><pre>' +
308 '<tr><td class="linenos"><div class="linenodiv"><pre>' +
309 ls + '</pre></div></td><td id="hlcode" class="code">')
309 ls + '</pre></div></td><td id="hlcode" class="code">')
310 yield 0, dummyoutfile.getvalue()
310 yield 0, dummyoutfile.getvalue()
311 yield 0, '</td></tr></table>'
311 yield 0, '</td></tr></table>'
312
312
313
313
314 class SearchContentCodeHtmlFormatter(CodeHtmlFormatter):
314 class SearchContentCodeHtmlFormatter(CodeHtmlFormatter):
315 def __init__(self, **kw):
315 def __init__(self, **kw):
316 # only show these line numbers if set
316 # only show these line numbers if set
317 self.only_lines = kw.pop('only_line_numbers', [])
317 self.only_lines = kw.pop('only_line_numbers', [])
318 self.query_terms = kw.pop('query_terms', [])
318 self.query_terms = kw.pop('query_terms', [])
319 self.max_lines = kw.pop('max_lines', 5)
319 self.max_lines = kw.pop('max_lines', 5)
320 self.line_context = kw.pop('line_context', 3)
320 self.line_context = kw.pop('line_context', 3)
321 self.url = kw.pop('url', None)
321 self.url = kw.pop('url', None)
322
322
323 super(CodeHtmlFormatter, self).__init__(**kw)
323 super(CodeHtmlFormatter, self).__init__(**kw)
324
324
325 def _wrap_code(self, source):
325 def _wrap_code(self, source):
326 for cnt, it in enumerate(source):
326 for cnt, it in enumerate(source):
327 i, t = it
327 i, t = it
328 t = '<pre>%s</pre>' % t
328 t = '<pre>%s</pre>' % t
329 yield i, t
329 yield i, t
330
330
331 def _wrap_tablelinenos(self, inner):
331 def _wrap_tablelinenos(self, inner):
332 yield 0, '<table class="code-highlight %stable">' % self.cssclass
332 yield 0, '<table class="code-highlight %stable">' % self.cssclass
333
333
334 last_shown_line_number = 0
334 last_shown_line_number = 0
335 current_line_number = 1
335 current_line_number = 1
336
336
337 for t, line in inner:
337 for t, line in inner:
338 if not t:
338 if not t:
339 yield t, line
339 yield t, line
340 continue
340 continue
341
341
342 if current_line_number in self.only_lines:
342 if current_line_number in self.only_lines:
343 if last_shown_line_number + 1 != current_line_number:
343 if last_shown_line_number + 1 != current_line_number:
344 yield 0, '<tr>'
344 yield 0, '<tr>'
345 yield 0, '<td class="line">...</td>'
345 yield 0, '<td class="line">...</td>'
346 yield 0, '<td id="hlcode" class="code"></td>'
346 yield 0, '<td id="hlcode" class="code"></td>'
347 yield 0, '</tr>'
347 yield 0, '</tr>'
348
348
349 yield 0, '<tr>'
349 yield 0, '<tr>'
350 if self.url:
350 if self.url:
351 yield 0, '<td class="line"><a href="%s#L%i">%i</a></td>' % (
351 yield 0, '<td class="line"><a href="%s#L%i">%i</a></td>' % (
352 self.url, current_line_number, current_line_number)
352 self.url, current_line_number, current_line_number)
353 else:
353 else:
354 yield 0, '<td class="line"><a href="">%i</a></td>' % (
354 yield 0, '<td class="line"><a href="">%i</a></td>' % (
355 current_line_number)
355 current_line_number)
356 yield 0, '<td id="hlcode" class="code">' + line + '</td>'
356 yield 0, '<td id="hlcode" class="code">' + line + '</td>'
357 yield 0, '</tr>'
357 yield 0, '</tr>'
358
358
359 last_shown_line_number = current_line_number
359 last_shown_line_number = current_line_number
360
360
361 current_line_number += 1
361 current_line_number += 1
362
362
363
363
364 yield 0, '</table>'
364 yield 0, '</table>'
365
365
366
366
367 def extract_phrases(text_query):
367 def extract_phrases(text_query):
368 """
368 """
369 Extracts phrases from search term string making sure phrases
369 Extracts phrases from search term string making sure phrases
370 contained in double quotes are kept together - and discarding empty values
370 contained in double quotes are kept together - and discarding empty values
371 or fully whitespace values eg.
371 or fully whitespace values eg.
372
372
373 'some text "a phrase" more' => ['some', 'text', 'a phrase', 'more']
373 'some text "a phrase" more' => ['some', 'text', 'a phrase', 'more']
374
374
375 """
375 """
376
376
377 in_phrase = False
377 in_phrase = False
378 buf = ''
378 buf = ''
379 phrases = []
379 phrases = []
380 for char in text_query:
380 for char in text_query:
381 if in_phrase:
381 if in_phrase:
382 if char == '"': # end phrase
382 if char == '"': # end phrase
383 phrases.append(buf)
383 phrases.append(buf)
384 buf = ''
384 buf = ''
385 in_phrase = False
385 in_phrase = False
386 continue
386 continue
387 else:
387 else:
388 buf += char
388 buf += char
389 continue
389 continue
390 else:
390 else:
391 if char == '"': # start phrase
391 if char == '"': # start phrase
392 in_phrase = True
392 in_phrase = True
393 phrases.append(buf)
393 phrases.append(buf)
394 buf = ''
394 buf = ''
395 continue
395 continue
396 elif char == ' ':
396 elif char == ' ':
397 phrases.append(buf)
397 phrases.append(buf)
398 buf = ''
398 buf = ''
399 continue
399 continue
400 else:
400 else:
401 buf += char
401 buf += char
402
402
403 phrases.append(buf)
403 phrases.append(buf)
404 phrases = [phrase.strip() for phrase in phrases if phrase.strip()]
404 phrases = [phrase.strip() for phrase in phrases if phrase.strip()]
405 return phrases
405 return phrases
406
406
407
407
408 def get_matching_offsets(text, phrases):
408 def get_matching_offsets(text, phrases):
409 """
409 """
410 Returns a list of string offsets in `text` that the list of `terms` match
410 Returns a list of string offsets in `text` that the list of `terms` match
411
411
412 >>> get_matching_offsets('some text here', ['some', 'here'])
412 >>> get_matching_offsets('some text here', ['some', 'here'])
413 [(0, 4), (10, 14)]
413 [(0, 4), (10, 14)]
414
414
415 """
415 """
416 offsets = []
416 offsets = []
417 for phrase in phrases:
417 for phrase in phrases:
418 for match in re.finditer(phrase, text):
418 for match in re.finditer(phrase, text):
419 offsets.append((match.start(), match.end()))
419 offsets.append((match.start(), match.end()))
420
420
421 return offsets
421 return offsets
422
422
423
423
424 def normalize_text_for_matching(x):
424 def normalize_text_for_matching(x):
425 """
425 """
426 Replaces all non alnum characters to spaces and lower cases the string,
426 Replaces all non alnum characters to spaces and lower cases the string,
427 useful for comparing two text strings without punctuation
427 useful for comparing two text strings without punctuation
428 """
428 """
429 return re.sub(r'[^\w]', ' ', x.lower())
429 return re.sub(r'[^\w]', ' ', x.lower())
430
430
431
431
432 def get_matching_line_offsets(lines, terms):
432 def get_matching_line_offsets(lines, terms):
433 """ Return a set of `lines` indices (starting from 1) matching a
433 """ Return a set of `lines` indices (starting from 1) matching a
434 text search query, along with `context` lines above/below matching lines
434 text search query, along with `context` lines above/below matching lines
435
435
436 :param lines: list of strings representing lines
436 :param lines: list of strings representing lines
437 :param terms: search term string to match in lines eg. 'some text'
437 :param terms: search term string to match in lines eg. 'some text'
438 :param context: number of lines above/below a matching line to add to result
438 :param context: number of lines above/below a matching line to add to result
439 :param max_lines: cut off for lines of interest
439 :param max_lines: cut off for lines of interest
440 eg.
440 eg.
441
441
442 text = '''
442 text = '''
443 words words words
443 words words words
444 words words words
444 words words words
445 some text some
445 some text some
446 words words words
446 words words words
447 words words words
447 words words words
448 text here what
448 text here what
449 '''
449 '''
450 get_matching_line_offsets(text, 'text', context=1)
450 get_matching_line_offsets(text, 'text', context=1)
451 {3: [(5, 9)], 6: [(0, 4)]]
451 {3: [(5, 9)], 6: [(0, 4)]]
452
452
453 """
453 """
454 matching_lines = {}
454 matching_lines = {}
455 phrases = [normalize_text_for_matching(phrase)
455 phrases = [normalize_text_for_matching(phrase)
456 for phrase in extract_phrases(terms)]
456 for phrase in extract_phrases(terms)]
457
457
458 for line_index, line in enumerate(lines, start=1):
458 for line_index, line in enumerate(lines, start=1):
459 match_offsets = get_matching_offsets(
459 match_offsets = get_matching_offsets(
460 normalize_text_for_matching(line), phrases)
460 normalize_text_for_matching(line), phrases)
461 if match_offsets:
461 if match_offsets:
462 matching_lines[line_index] = match_offsets
462 matching_lines[line_index] = match_offsets
463
463
464 return matching_lines
464 return matching_lines
465
465
466
466
467 def get_lexer_safe(mimetype=None, filepath=None):
467 def get_lexer_safe(mimetype=None, filepath=None):
468 """
468 """
469 Tries to return a relevant pygments lexer using mimetype/filepath name,
469 Tries to return a relevant pygments lexer using mimetype/filepath name,
470 defaulting to plain text if none could be found
470 defaulting to plain text if none could be found
471 """
471 """
472 lexer = None
472 lexer = None
473 try:
473 try:
474 if mimetype:
474 if mimetype:
475 lexer = get_lexer_for_mimetype(mimetype)
475 lexer = get_lexer_for_mimetype(mimetype)
476 if not lexer:
476 if not lexer:
477 lexer = get_lexer_for_filename(filepath)
477 lexer = get_lexer_for_filename(filepath)
478 except pygments.util.ClassNotFound:
478 except pygments.util.ClassNotFound:
479 pass
479 pass
480
480
481 if not lexer:
481 if not lexer:
482 lexer = get_lexer_by_name('text')
482 lexer = get_lexer_by_name('text')
483
483
484 return lexer
484 return lexer
485
485
486
486
487 def pygmentize(filenode, **kwargs):
487 def pygmentize(filenode, **kwargs):
488 """
488 """
489 pygmentize function using pygments
489 pygmentize function using pygments
490
490
491 :param filenode:
491 :param filenode:
492 """
492 """
493 lexer = get_custom_lexer(filenode.extension) or filenode.lexer
493 lexer = get_custom_lexer(filenode.extension) or filenode.lexer
494 return literal(code_highlight(filenode.content, lexer,
494 return literal(code_highlight(filenode.content, lexer,
495 CodeHtmlFormatter(**kwargs)))
495 CodeHtmlFormatter(**kwargs)))
496
496
497
497
498 def pygmentize_annotation(repo_name, filenode, **kwargs):
498 def pygmentize_annotation(repo_name, filenode, **kwargs):
499 """
499 """
500 pygmentize function for annotation
500 pygmentize function for annotation
501
501
502 :param filenode:
502 :param filenode:
503 """
503 """
504
504
505 color_dict = {}
505 color_dict = {}
506
506
507 def gen_color(n=10000):
507 def gen_color(n=10000):
508 """generator for getting n of evenly distributed colors using
508 """generator for getting n of evenly distributed colors using
509 hsv color and golden ratio. It always return same order of colors
509 hsv color and golden ratio. It always return same order of colors
510
510
511 :returns: RGB tuple
511 :returns: RGB tuple
512 """
512 """
513
513
514 def hsv_to_rgb(h, s, v):
514 def hsv_to_rgb(h, s, v):
515 if s == 0.0:
515 if s == 0.0:
516 return v, v, v
516 return v, v, v
517 i = int(h * 6.0) # XXX assume int() truncates!
517 i = int(h * 6.0) # XXX assume int() truncates!
518 f = (h * 6.0) - i
518 f = (h * 6.0) - i
519 p = v * (1.0 - s)
519 p = v * (1.0 - s)
520 q = v * (1.0 - s * f)
520 q = v * (1.0 - s * f)
521 t = v * (1.0 - s * (1.0 - f))
521 t = v * (1.0 - s * (1.0 - f))
522 i = i % 6
522 i = i % 6
523 if i == 0:
523 if i == 0:
524 return v, t, p
524 return v, t, p
525 if i == 1:
525 if i == 1:
526 return q, v, p
526 return q, v, p
527 if i == 2:
527 if i == 2:
528 return p, v, t
528 return p, v, t
529 if i == 3:
529 if i == 3:
530 return p, q, v
530 return p, q, v
531 if i == 4:
531 if i == 4:
532 return t, p, v
532 return t, p, v
533 if i == 5:
533 if i == 5:
534 return v, p, q
534 return v, p, q
535
535
536 golden_ratio = 0.618033988749895
536 golden_ratio = 0.618033988749895
537 h = 0.22717784590367374
537 h = 0.22717784590367374
538
538
539 for _ in xrange(n):
539 for _ in xrange(n):
540 h += golden_ratio
540 h += golden_ratio
541 h %= 1
541 h %= 1
542 HSV_tuple = [h, 0.95, 0.95]
542 HSV_tuple = [h, 0.95, 0.95]
543 RGB_tuple = hsv_to_rgb(*HSV_tuple)
543 RGB_tuple = hsv_to_rgb(*HSV_tuple)
544 yield map(lambda x: str(int(x * 256)), RGB_tuple)
544 yield map(lambda x: str(int(x * 256)), RGB_tuple)
545
545
546 cgenerator = gen_color()
546 cgenerator = gen_color()
547
547
548 def get_color_string(commit_id):
548 def get_color_string(commit_id):
549 if commit_id in color_dict:
549 if commit_id in color_dict:
550 col = color_dict[commit_id]
550 col = color_dict[commit_id]
551 else:
551 else:
552 col = color_dict[commit_id] = cgenerator.next()
552 col = color_dict[commit_id] = cgenerator.next()
553 return "color: rgb(%s)! important;" % (', '.join(col))
553 return "color: rgb(%s)! important;" % (', '.join(col))
554
554
555 def url_func(repo_name):
555 def url_func(repo_name):
556
556
557 def _url_func(commit):
557 def _url_func(commit):
558 author = commit.author
558 author = commit.author
559 date = commit.date
559 date = commit.date
560 message = tooltip(commit.message)
560 message = tooltip(commit.message)
561
561
562 tooltip_html = ("<div style='font-size:0.8em'><b>Author:</b>"
562 tooltip_html = ("<div style='font-size:0.8em'><b>Author:</b>"
563 " %s<br/><b>Date:</b> %s</b><br/><b>Message:"
563 " %s<br/><b>Date:</b> %s</b><br/><b>Message:"
564 "</b> %s<br/></div>")
564 "</b> %s<br/></div>")
565
565
566 tooltip_html = tooltip_html % (author, date, message)
566 tooltip_html = tooltip_html % (author, date, message)
567 lnk_format = '%5s:%s' % ('r%s' % commit.idx, commit.short_id)
567 lnk_format = '%5s:%s' % ('r%s' % commit.idx, commit.short_id)
568 uri = link_to(
568 uri = link_to(
569 lnk_format,
569 lnk_format,
570 url('changeset_home', repo_name=repo_name,
570 url('changeset_home', repo_name=repo_name,
571 revision=commit.raw_id),
571 revision=commit.raw_id),
572 style=get_color_string(commit.raw_id),
572 style=get_color_string(commit.raw_id),
573 class_='tooltip',
573 class_='tooltip',
574 title=tooltip_html
574 title=tooltip_html
575 )
575 )
576
576
577 uri += '\n'
577 uri += '\n'
578 return uri
578 return uri
579 return _url_func
579 return _url_func
580
580
581 return literal(annotate_highlight(filenode, url_func(repo_name), **kwargs))
581 return literal(annotate_highlight(filenode, url_func(repo_name), **kwargs))
582
582
583
583
584 def is_following_repo(repo_name, user_id):
584 def is_following_repo(repo_name, user_id):
585 from rhodecode.model.scm import ScmModel
585 from rhodecode.model.scm import ScmModel
586 return ScmModel().is_following_repo(repo_name, user_id)
586 return ScmModel().is_following_repo(repo_name, user_id)
587
587
588
588
589 class _Message(object):
589 class _Message(object):
590 """A message returned by ``Flash.pop_messages()``.
590 """A message returned by ``Flash.pop_messages()``.
591
591
592 Converting the message to a string returns the message text. Instances
592 Converting the message to a string returns the message text. Instances
593 also have the following attributes:
593 also have the following attributes:
594
594
595 * ``message``: the message text.
595 * ``message``: the message text.
596 * ``category``: the category specified when the message was created.
596 * ``category``: the category specified when the message was created.
597 """
597 """
598
598
599 def __init__(self, category, message):
599 def __init__(self, category, message):
600 self.category = category
600 self.category = category
601 self.message = message
601 self.message = message
602
602
603 def __str__(self):
603 def __str__(self):
604 return self.message
604 return self.message
605
605
606 __unicode__ = __str__
606 __unicode__ = __str__
607
607
608 def __html__(self):
608 def __html__(self):
609 return escape(safe_unicode(self.message))
609 return escape(safe_unicode(self.message))
610
610
611
611
612 class Flash(_Flash):
612 class Flash(_Flash):
613
613
614 def pop_messages(self):
614 def pop_messages(self):
615 """Return all accumulated messages and delete them from the session.
615 """Return all accumulated messages and delete them from the session.
616
616
617 The return value is a list of ``Message`` objects.
617 The return value is a list of ``Message`` objects.
618 """
618 """
619 from pylons import session
619 from pylons import session
620
620
621 messages = []
621 messages = []
622
622
623 # Pop the 'old' pylons flash messages. They are tuples of the form
623 # Pop the 'old' pylons flash messages. They are tuples of the form
624 # (category, message)
624 # (category, message)
625 for cat, msg in session.pop(self.session_key, []):
625 for cat, msg in session.pop(self.session_key, []):
626 messages.append(_Message(cat, msg))
626 messages.append(_Message(cat, msg))
627
627
628 # Pop the 'new' pyramid flash messages for each category as list
628 # Pop the 'new' pyramid flash messages for each category as list
629 # of strings.
629 # of strings.
630 for cat in self.categories:
630 for cat in self.categories:
631 for msg in session.pop_flash(queue=cat):
631 for msg in session.pop_flash(queue=cat):
632 messages.append(_Message(cat, msg))
632 messages.append(_Message(cat, msg))
633 # Map messages from the default queue to the 'notice' category.
633 # Map messages from the default queue to the 'notice' category.
634 for msg in session.pop_flash():
634 for msg in session.pop_flash():
635 messages.append(_Message('notice', msg))
635 messages.append(_Message('notice', msg))
636
636
637 session.save()
637 session.save()
638 return messages
638 return messages
639
639
640 flash = Flash()
640 flash = Flash()
641
641
642 #==============================================================================
642 #==============================================================================
643 # SCM FILTERS available via h.
643 # SCM FILTERS available via h.
644 #==============================================================================
644 #==============================================================================
645 from rhodecode.lib.vcs.utils import author_name, author_email
645 from rhodecode.lib.vcs.utils import author_name, author_email
646 from rhodecode.lib.utils2 import credentials_filter, age as _age
646 from rhodecode.lib.utils2 import credentials_filter, age as _age
647 from rhodecode.model.db import User, ChangesetStatus
647 from rhodecode.model.db import User, ChangesetStatus
648
648
649 age = _age
649 age = _age
650 capitalize = lambda x: x.capitalize()
650 capitalize = lambda x: x.capitalize()
651 email = author_email
651 email = author_email
652 short_id = lambda x: x[:12]
652 short_id = lambda x: x[:12]
653 hide_credentials = lambda x: ''.join(credentials_filter(x))
653 hide_credentials = lambda x: ''.join(credentials_filter(x))
654
654
655
655
656 def age_component(datetime_iso, value=None, time_is_local=False):
656 def age_component(datetime_iso, value=None, time_is_local=False):
657 title = value or format_date(datetime_iso)
657 title = value or format_date(datetime_iso)
658
658
659 # detect if we have a timezone info, otherwise, add it
659 # detect if we have a timezone info, otherwise, add it
660 if isinstance(datetime_iso, datetime) and not datetime_iso.tzinfo:
660 if isinstance(datetime_iso, datetime) and not datetime_iso.tzinfo:
661 tzinfo = '+00:00'
661 tzinfo = '+00:00'
662
662
663 if time_is_local:
663 if time_is_local:
664 tzinfo = time.strftime("+%H:%M",
664 tzinfo = time.strftime("+%H:%M",
665 time.gmtime(
665 time.gmtime(
666 (datetime.now() - datetime.utcnow()).seconds + 1
666 (datetime.now() - datetime.utcnow()).seconds + 1
667 )
667 )
668 )
668 )
669
669
670 return literal(
670 return literal(
671 '<time class="timeago tooltip" '
671 '<time class="timeago tooltip" '
672 'title="{1}" datetime="{0}{2}">{1}</time>'.format(
672 'title="{1}" datetime="{0}{2}">{1}</time>'.format(
673 datetime_iso, title, tzinfo))
673 datetime_iso, title, tzinfo))
674
674
675
675
676 def _shorten_commit_id(commit_id):
676 def _shorten_commit_id(commit_id):
677 from rhodecode import CONFIG
677 from rhodecode import CONFIG
678 def_len = safe_int(CONFIG.get('rhodecode_show_sha_length', 12))
678 def_len = safe_int(CONFIG.get('rhodecode_show_sha_length', 12))
679 return commit_id[:def_len]
679 return commit_id[:def_len]
680
680
681
681
682 def show_id(commit):
682 def show_id(commit):
683 """
683 """
684 Configurable function that shows ID
684 Configurable function that shows ID
685 by default it's r123:fffeeefffeee
685 by default it's r123:fffeeefffeee
686
686
687 :param commit: commit instance
687 :param commit: commit instance
688 """
688 """
689 from rhodecode import CONFIG
689 from rhodecode import CONFIG
690 show_idx = str2bool(CONFIG.get('rhodecode_show_revision_number', True))
690 show_idx = str2bool(CONFIG.get('rhodecode_show_revision_number', True))
691
691
692 raw_id = _shorten_commit_id(commit.raw_id)
692 raw_id = _shorten_commit_id(commit.raw_id)
693 if show_idx:
693 if show_idx:
694 return 'r%s:%s' % (commit.idx, raw_id)
694 return 'r%s:%s' % (commit.idx, raw_id)
695 else:
695 else:
696 return '%s' % (raw_id, )
696 return '%s' % (raw_id, )
697
697
698
698
699 def format_date(date):
699 def format_date(date):
700 """
700 """
701 use a standardized formatting for dates used in RhodeCode
701 use a standardized formatting for dates used in RhodeCode
702
702
703 :param date: date/datetime object
703 :param date: date/datetime object
704 :return: formatted date
704 :return: formatted date
705 """
705 """
706
706
707 if date:
707 if date:
708 _fmt = "%a, %d %b %Y %H:%M:%S"
708 _fmt = "%a, %d %b %Y %H:%M:%S"
709 return safe_unicode(date.strftime(_fmt))
709 return safe_unicode(date.strftime(_fmt))
710
710
711 return u""
711 return u""
712
712
713
713
714 class _RepoChecker(object):
714 class _RepoChecker(object):
715
715
716 def __init__(self, backend_alias):
716 def __init__(self, backend_alias):
717 self._backend_alias = backend_alias
717 self._backend_alias = backend_alias
718
718
719 def __call__(self, repository):
719 def __call__(self, repository):
720 if hasattr(repository, 'alias'):
720 if hasattr(repository, 'alias'):
721 _type = repository.alias
721 _type = repository.alias
722 elif hasattr(repository, 'repo_type'):
722 elif hasattr(repository, 'repo_type'):
723 _type = repository.repo_type
723 _type = repository.repo_type
724 else:
724 else:
725 _type = repository
725 _type = repository
726 return _type == self._backend_alias
726 return _type == self._backend_alias
727
727
728 is_git = _RepoChecker('git')
728 is_git = _RepoChecker('git')
729 is_hg = _RepoChecker('hg')
729 is_hg = _RepoChecker('hg')
730 is_svn = _RepoChecker('svn')
730 is_svn = _RepoChecker('svn')
731
731
732
732
733 def get_repo_type_by_name(repo_name):
733 def get_repo_type_by_name(repo_name):
734 repo = Repository.get_by_repo_name(repo_name)
734 repo = Repository.get_by_repo_name(repo_name)
735 return repo.repo_type
735 return repo.repo_type
736
736
737
737
738 def is_svn_without_proxy(repository):
738 def is_svn_without_proxy(repository):
739 from rhodecode import CONFIG
739 from rhodecode import CONFIG
740 if is_svn(repository):
740 if is_svn(repository):
741 if not CONFIG.get('rhodecode_proxy_subversion_http_requests', False):
741 if not CONFIG.get('rhodecode_proxy_subversion_http_requests', False):
742 return True
742 return True
743 return False
743 return False
744
744
745
745
746 def discover_user(author):
746 def discover_user(author):
747 """
747 """
748 Tries to discover RhodeCode User based on the autho string. Author string
748 Tries to discover RhodeCode User based on the autho string. Author string
749 is typically `FirstName LastName <email@address.com>`
749 is typically `FirstName LastName <email@address.com>`
750 """
750 """
751
751
752 # if author is already an instance use it for extraction
752 # if author is already an instance use it for extraction
753 if isinstance(author, User):
753 if isinstance(author, User):
754 return author
754 return author
755
755
756 # Valid email in the attribute passed, see if they're in the system
756 # Valid email in the attribute passed, see if they're in the system
757 _email = author_email(author)
757 _email = author_email(author)
758 if _email != '':
758 if _email != '':
759 user = User.get_by_email(_email, case_insensitive=True, cache=True)
759 user = User.get_by_email(_email, case_insensitive=True, cache=True)
760 if user is not None:
760 if user is not None:
761 return user
761 return user
762
762
763 # Maybe it's a username, we try to extract it and fetch by username ?
763 # Maybe it's a username, we try to extract it and fetch by username ?
764 _author = author_name(author)
764 _author = author_name(author)
765 user = User.get_by_username(_author, case_insensitive=True, cache=True)
765 user = User.get_by_username(_author, case_insensitive=True, cache=True)
766 if user is not None:
766 if user is not None:
767 return user
767 return user
768
768
769 return None
769 return None
770
770
771
771
772 def email_or_none(author):
772 def email_or_none(author):
773 # extract email from the commit string
773 # extract email from the commit string
774 _email = author_email(author)
774 _email = author_email(author)
775
776 # If we have an email, use it, otherwise
777 # see if it contains a username we can get an email from
775 if _email != '':
778 if _email != '':
776 # check it against RhodeCode database, and use the MAIN email for this
777 # user
778 user = User.get_by_email(_email, case_insensitive=True, cache=True)
779 if user is not None:
780 return user.email
781 return _email
779 return _email
782
780 else:
783 # See if it contains a username we can get an email from
784 user = User.get_by_username(author_name(author), case_insensitive=True,
781 user = User.get_by_username(author_name(author), case_insensitive=True,
785 cache=True)
782 cache=True)
783
786 if user is not None:
784 if user is not None:
787 return user.email
785 return user.email
788
786
789 # No valid email, not a valid user in the system, none!
787 # No valid email, not a valid user in the system, none!
790 return None
788 return None
791
789
792
790
793 def link_to_user(author, length=0, **kwargs):
791 def link_to_user(author, length=0, **kwargs):
794 user = discover_user(author)
792 user = discover_user(author)
795 # user can be None, but if we have it already it means we can re-use it
793 # user can be None, but if we have it already it means we can re-use it
796 # in the person() function, so we save 1 intensive-query
794 # in the person() function, so we save 1 intensive-query
797 if user:
795 if user:
798 author = user
796 author = user
799
797
800 display_person = person(author, 'username_or_name_or_email')
798 display_person = person(author, 'username_or_name_or_email')
801 if length:
799 if length:
802 display_person = shorter(display_person, length)
800 display_person = shorter(display_person, length)
803
801
804 if user:
802 if user:
805 return link_to(
803 return link_to(
806 escape(display_person),
804 escape(display_person),
807 url('user_profile', username=user.username),
805 url('user_profile', username=user.username),
808 **kwargs)
806 **kwargs)
809 else:
807 else:
810 return escape(display_person)
808 return escape(display_person)
811
809
812
810
813 def person(author, show_attr="username_and_name"):
811 def person(author, show_attr="username_and_name"):
814 user = discover_user(author)
812 user = discover_user(author)
815 if user:
813 if user:
816 return getattr(user, show_attr)
814 return getattr(user, show_attr)
817 else:
815 else:
818 _author = author_name(author)
816 _author = author_name(author)
819 _email = email(author)
817 _email = email(author)
820 return _author or _email
818 return _author or _email
821
819
822
820
823 def person_by_id(id_, show_attr="username_and_name"):
821 def person_by_id(id_, show_attr="username_and_name"):
824 # attr to return from fetched user
822 # attr to return from fetched user
825 person_getter = lambda usr: getattr(usr, show_attr)
823 person_getter = lambda usr: getattr(usr, show_attr)
826
824
827 #maybe it's an ID ?
825 #maybe it's an ID ?
828 if str(id_).isdigit() or isinstance(id_, int):
826 if str(id_).isdigit() or isinstance(id_, int):
829 id_ = int(id_)
827 id_ = int(id_)
830 user = User.get(id_)
828 user = User.get(id_)
831 if user is not None:
829 if user is not None:
832 return person_getter(user)
830 return person_getter(user)
833 return id_
831 return id_
834
832
835
833
836 def gravatar_with_user(author, show_disabled=False):
834 def gravatar_with_user(author, show_disabled=False):
837 from rhodecode.lib.utils import PartialRenderer
835 from rhodecode.lib.utils import PartialRenderer
838 _render = PartialRenderer('base/base.html')
836 _render = PartialRenderer('base/base.html')
839 return _render('gravatar_with_user', author, show_disabled=show_disabled)
837 return _render('gravatar_with_user', author, show_disabled=show_disabled)
840
838
841
839
842 def desc_stylize(value):
840 def desc_stylize(value):
843 """
841 """
844 converts tags from value into html equivalent
842 converts tags from value into html equivalent
845
843
846 :param value:
844 :param value:
847 """
845 """
848 if not value:
846 if not value:
849 return ''
847 return ''
850
848
851 value = re.sub(r'\[see\ \=\>\ *([a-zA-Z0-9\/\=\?\&\ \:\/\.\-]*)\]',
849 value = re.sub(r'\[see\ \=\>\ *([a-zA-Z0-9\/\=\?\&\ \:\/\.\-]*)\]',
852 '<div class="metatag" tag="see">see =&gt; \\1 </div>', value)
850 '<div class="metatag" tag="see">see =&gt; \\1 </div>', value)
853 value = re.sub(r'\[license\ \=\>\ *([a-zA-Z0-9\/\=\?\&\ \:\/\.\-]*)\]',
851 value = re.sub(r'\[license\ \=\>\ *([a-zA-Z0-9\/\=\?\&\ \:\/\.\-]*)\]',
854 '<div class="metatag" tag="license"><a href="http:\/\/www.opensource.org/licenses/\\1">\\1</a></div>', value)
852 '<div class="metatag" tag="license"><a href="http:\/\/www.opensource.org/licenses/\\1">\\1</a></div>', value)
855 value = re.sub(r'\[(requires|recommends|conflicts|base)\ \=\>\ *([a-zA-Z0-9\-\/]*)\]',
853 value = re.sub(r'\[(requires|recommends|conflicts|base)\ \=\>\ *([a-zA-Z0-9\-\/]*)\]',
856 '<div class="metatag" tag="\\1">\\1 =&gt; <a href="/\\2">\\2</a></div>', value)
854 '<div class="metatag" tag="\\1">\\1 =&gt; <a href="/\\2">\\2</a></div>', value)
857 value = re.sub(r'\[(lang|language)\ \=\>\ *([a-zA-Z\-\/\#\+]*)\]',
855 value = re.sub(r'\[(lang|language)\ \=\>\ *([a-zA-Z\-\/\#\+]*)\]',
858 '<div class="metatag" tag="lang">\\2</div>', value)
856 '<div class="metatag" tag="lang">\\2</div>', value)
859 value = re.sub(r'\[([a-z]+)\]',
857 value = re.sub(r'\[([a-z]+)\]',
860 '<div class="metatag" tag="\\1">\\1</div>', value)
858 '<div class="metatag" tag="\\1">\\1</div>', value)
861
859
862 return value
860 return value
863
861
864
862
865 def escaped_stylize(value):
863 def escaped_stylize(value):
866 """
864 """
867 converts tags from value into html equivalent, but escaping its value first
865 converts tags from value into html equivalent, but escaping its value first
868 """
866 """
869 if not value:
867 if not value:
870 return ''
868 return ''
871
869
872 # Using default webhelper escape method, but has to force it as a
870 # Using default webhelper escape method, but has to force it as a
873 # plain unicode instead of a markup tag to be used in regex expressions
871 # plain unicode instead of a markup tag to be used in regex expressions
874 value = unicode(escape(safe_unicode(value)))
872 value = unicode(escape(safe_unicode(value)))
875
873
876 value = re.sub(r'\[see\ \=\&gt;\ *([a-zA-Z0-9\/\=\?\&amp;\ \:\/\.\-]*)\]',
874 value = re.sub(r'\[see\ \=\&gt;\ *([a-zA-Z0-9\/\=\?\&amp;\ \:\/\.\-]*)\]',
877 '<div class="metatag" tag="see">see =&gt; \\1 </div>', value)
875 '<div class="metatag" tag="see">see =&gt; \\1 </div>', value)
878 value = re.sub(r'\[license\ \=\&gt;\ *([a-zA-Z0-9\/\=\?\&amp;\ \:\/\.\-]*)\]',
876 value = re.sub(r'\[license\ \=\&gt;\ *([a-zA-Z0-9\/\=\?\&amp;\ \:\/\.\-]*)\]',
879 '<div class="metatag" tag="license"><a href="http:\/\/www.opensource.org/licenses/\\1">\\1</a></div>', value)
877 '<div class="metatag" tag="license"><a href="http:\/\/www.opensource.org/licenses/\\1">\\1</a></div>', value)
880 value = re.sub(r'\[(requires|recommends|conflicts|base)\ \=\&gt;\ *([a-zA-Z0-9\-\/]*)\]',
878 value = re.sub(r'\[(requires|recommends|conflicts|base)\ \=\&gt;\ *([a-zA-Z0-9\-\/]*)\]',
881 '<div class="metatag" tag="\\1">\\1 =&gt; <a href="/\\2">\\2</a></div>', value)
879 '<div class="metatag" tag="\\1">\\1 =&gt; <a href="/\\2">\\2</a></div>', value)
882 value = re.sub(r'\[(lang|language)\ \=\&gt;\ *([a-zA-Z\-\/\#\+]*)\]',
880 value = re.sub(r'\[(lang|language)\ \=\&gt;\ *([a-zA-Z\-\/\#\+]*)\]',
883 '<div class="metatag" tag="lang">\\2</div>', value)
881 '<div class="metatag" tag="lang">\\2</div>', value)
884 value = re.sub(r'\[([a-z]+)\]',
882 value = re.sub(r'\[([a-z]+)\]',
885 '<div class="metatag" tag="\\1">\\1</div>', value)
883 '<div class="metatag" tag="\\1">\\1</div>', value)
886
884
887 return value
885 return value
888
886
889
887
890 def bool2icon(value):
888 def bool2icon(value):
891 """
889 """
892 Returns boolean value of a given value, represented as html element with
890 Returns boolean value of a given value, represented as html element with
893 classes that will represent icons
891 classes that will represent icons
894
892
895 :param value: given value to convert to html node
893 :param value: given value to convert to html node
896 """
894 """
897
895
898 if value: # does bool conversion
896 if value: # does bool conversion
899 return HTML.tag('i', class_="icon-true")
897 return HTML.tag('i', class_="icon-true")
900 else: # not true as bool
898 else: # not true as bool
901 return HTML.tag('i', class_="icon-false")
899 return HTML.tag('i', class_="icon-false")
902
900
903
901
904 #==============================================================================
902 #==============================================================================
905 # PERMS
903 # PERMS
906 #==============================================================================
904 #==============================================================================
907 from rhodecode.lib.auth import HasPermissionAny, HasPermissionAll, \
905 from rhodecode.lib.auth import HasPermissionAny, HasPermissionAll, \
908 HasRepoPermissionAny, HasRepoPermissionAll, HasRepoGroupPermissionAll, \
906 HasRepoPermissionAny, HasRepoPermissionAll, HasRepoGroupPermissionAll, \
909 HasRepoGroupPermissionAny, HasRepoPermissionAnyApi, get_csrf_token
907 HasRepoGroupPermissionAny, HasRepoPermissionAnyApi, get_csrf_token
910
908
911
909
912 #==============================================================================
910 #==============================================================================
913 # GRAVATAR URL
911 # GRAVATAR URL
914 #==============================================================================
912 #==============================================================================
915 class InitialsGravatar(object):
913 class InitialsGravatar(object):
916 def __init__(self, email_address, first_name, last_name, size=30,
914 def __init__(self, email_address, first_name, last_name, size=30,
917 background=None, text_color='#fff'):
915 background=None, text_color='#fff'):
918 self.size = size
916 self.size = size
919 self.first_name = first_name
917 self.first_name = first_name
920 self.last_name = last_name
918 self.last_name = last_name
921 self.email_address = email_address
919 self.email_address = email_address
922 self.background = background or self.str2color(email_address)
920 self.background = background or self.str2color(email_address)
923 self.text_color = text_color
921 self.text_color = text_color
924
922
925 def get_color_bank(self):
923 def get_color_bank(self):
926 """
924 """
927 returns a predefined list of colors that gravatars can use.
925 returns a predefined list of colors that gravatars can use.
928 Those are randomized distinct colors that guarantee readability and
926 Those are randomized distinct colors that guarantee readability and
929 uniqueness.
927 uniqueness.
930
928
931 generated with: http://phrogz.net/css/distinct-colors.html
929 generated with: http://phrogz.net/css/distinct-colors.html
932 """
930 """
933 return [
931 return [
934 '#bf3030', '#a67f53', '#00ff00', '#5989b3', '#392040', '#d90000',
932 '#bf3030', '#a67f53', '#00ff00', '#5989b3', '#392040', '#d90000',
935 '#402910', '#204020', '#79baf2', '#a700b3', '#bf6060', '#7f5320',
933 '#402910', '#204020', '#79baf2', '#a700b3', '#bf6060', '#7f5320',
936 '#008000', '#003059', '#ee00ff', '#ff0000', '#8c4b00', '#007300',
934 '#008000', '#003059', '#ee00ff', '#ff0000', '#8c4b00', '#007300',
937 '#005fb3', '#de73e6', '#ff4040', '#ffaa00', '#3df255', '#203140',
935 '#005fb3', '#de73e6', '#ff4040', '#ffaa00', '#3df255', '#203140',
938 '#47004d', '#591616', '#664400', '#59b365', '#0d2133', '#83008c',
936 '#47004d', '#591616', '#664400', '#59b365', '#0d2133', '#83008c',
939 '#592d2d', '#bf9f60', '#73e682', '#1d3f73', '#73006b', '#402020',
937 '#592d2d', '#bf9f60', '#73e682', '#1d3f73', '#73006b', '#402020',
940 '#b2862d', '#397341', '#597db3', '#e600d6', '#a60000', '#736039',
938 '#b2862d', '#397341', '#597db3', '#e600d6', '#a60000', '#736039',
941 '#00b318', '#79aaf2', '#330d30', '#ff8080', '#403010', '#16591f',
939 '#00b318', '#79aaf2', '#330d30', '#ff8080', '#403010', '#16591f',
942 '#002459', '#8c4688', '#e50000', '#ffbf40', '#00732e', '#102340',
940 '#002459', '#8c4688', '#e50000', '#ffbf40', '#00732e', '#102340',
943 '#bf60ac', '#8c4646', '#cc8800', '#00a642', '#1d3473', '#b32d98',
941 '#bf60ac', '#8c4646', '#cc8800', '#00a642', '#1d3473', '#b32d98',
944 '#660e00', '#ffd580', '#80ffb2', '#7391e6', '#733967', '#d97b6c',
942 '#660e00', '#ffd580', '#80ffb2', '#7391e6', '#733967', '#d97b6c',
945 '#8c5e00', '#59b389', '#3967e6', '#590047', '#73281d', '#665200',
943 '#8c5e00', '#59b389', '#3967e6', '#590047', '#73281d', '#665200',
946 '#00e67a', '#2d50b3', '#8c2377', '#734139', '#b2982d', '#16593a',
944 '#00e67a', '#2d50b3', '#8c2377', '#734139', '#b2982d', '#16593a',
947 '#001859', '#ff00aa', '#a65e53', '#ffcc00', '#0d3321', '#2d3959',
945 '#001859', '#ff00aa', '#a65e53', '#ffcc00', '#0d3321', '#2d3959',
948 '#731d56', '#401610', '#4c3d00', '#468c6c', '#002ca6', '#d936a3',
946 '#731d56', '#401610', '#4c3d00', '#468c6c', '#002ca6', '#d936a3',
949 '#d94c36', '#403920', '#36d9a3', '#0d1733', '#592d4a', '#993626',
947 '#d94c36', '#403920', '#36d9a3', '#0d1733', '#592d4a', '#993626',
950 '#cca300', '#00734d', '#46598c', '#8c005e', '#7f1100', '#8c7000',
948 '#cca300', '#00734d', '#46598c', '#8c005e', '#7f1100', '#8c7000',
951 '#00a66f', '#7382e6', '#b32d74', '#d9896c', '#ffe680', '#1d7362',
949 '#00a66f', '#7382e6', '#b32d74', '#d9896c', '#ffe680', '#1d7362',
952 '#364cd9', '#73003d', '#d93a00', '#998a4d', '#59b3a1', '#5965b3',
950 '#364cd9', '#73003d', '#d93a00', '#998a4d', '#59b3a1', '#5965b3',
953 '#e5007a', '#73341d', '#665f00', '#00b38f', '#0018b3', '#59163a',
951 '#e5007a', '#73341d', '#665f00', '#00b38f', '#0018b3', '#59163a',
954 '#b2502d', '#bfb960', '#00ffcc', '#23318c', '#a6537f', '#734939',
952 '#b2502d', '#bfb960', '#00ffcc', '#23318c', '#a6537f', '#734939',
955 '#b2a700', '#104036', '#3d3df2', '#402031', '#e56739', '#736f39',
953 '#b2a700', '#104036', '#3d3df2', '#402031', '#e56739', '#736f39',
956 '#79f2ea', '#000059', '#401029', '#4c1400', '#ffee00', '#005953',
954 '#79f2ea', '#000059', '#401029', '#4c1400', '#ffee00', '#005953',
957 '#101040', '#990052', '#402820', '#403d10', '#00ffee', '#0000d9',
955 '#101040', '#990052', '#402820', '#403d10', '#00ffee', '#0000d9',
958 '#ff80c4', '#a66953', '#eeff00', '#00ccbe', '#8080ff', '#e673a1',
956 '#ff80c4', '#a66953', '#eeff00', '#00ccbe', '#8080ff', '#e673a1',
959 '#a62c00', '#474d00', '#1a3331', '#46468c', '#733950', '#662900',
957 '#a62c00', '#474d00', '#1a3331', '#46468c', '#733950', '#662900',
960 '#858c23', '#238c85', '#0f0073', '#b20047', '#d9986c', '#becc00',
958 '#858c23', '#238c85', '#0f0073', '#b20047', '#d9986c', '#becc00',
961 '#396f73', '#281d73', '#ff0066', '#ff6600', '#dee673', '#59adb3',
959 '#396f73', '#281d73', '#ff0066', '#ff6600', '#dee673', '#59adb3',
962 '#6559b3', '#590024', '#b2622d', '#98b32d', '#36ced9', '#332d59',
960 '#6559b3', '#590024', '#b2622d', '#98b32d', '#36ced9', '#332d59',
963 '#40001a', '#733f1d', '#526600', '#005359', '#242040', '#bf6079',
961 '#40001a', '#733f1d', '#526600', '#005359', '#242040', '#bf6079',
964 '#735039', '#cef23d', '#007780', '#5630bf', '#66001b', '#b24700',
962 '#735039', '#cef23d', '#007780', '#5630bf', '#66001b', '#b24700',
965 '#acbf60', '#1d6273', '#25008c', '#731d34', '#a67453', '#50592d',
963 '#acbf60', '#1d6273', '#25008c', '#731d34', '#a67453', '#50592d',
966 '#00ccff', '#6600ff', '#ff0044', '#4c1f00', '#8a994d', '#79daf2',
964 '#00ccff', '#6600ff', '#ff0044', '#4c1f00', '#8a994d', '#79daf2',
967 '#a173e6', '#d93662', '#402310', '#aaff00', '#2d98b3', '#8c40ff',
965 '#a173e6', '#d93662', '#402310', '#aaff00', '#2d98b3', '#8c40ff',
968 '#592d39', '#ff8c40', '#354020', '#103640', '#1a0040', '#331a20',
966 '#592d39', '#ff8c40', '#354020', '#103640', '#1a0040', '#331a20',
969 '#331400', '#334d00', '#1d5673', '#583973', '#7f0022', '#4c3626',
967 '#331400', '#334d00', '#1d5673', '#583973', '#7f0022', '#4c3626',
970 '#88cc00', '#36a3d9', '#3d0073', '#d9364c', '#33241a', '#698c23',
968 '#88cc00', '#36a3d9', '#3d0073', '#d9364c', '#33241a', '#698c23',
971 '#5995b3', '#300059', '#e57382', '#7f3300', '#366600', '#00aaff',
969 '#5995b3', '#300059', '#e57382', '#7f3300', '#366600', '#00aaff',
972 '#3a1659', '#733941', '#663600', '#74b32d', '#003c59', '#7f53a6',
970 '#3a1659', '#733941', '#663600', '#74b32d', '#003c59', '#7f53a6',
973 '#73000f', '#ff8800', '#baf279', '#79caf2', '#291040', '#a6293a',
971 '#73000f', '#ff8800', '#baf279', '#79caf2', '#291040', '#a6293a',
974 '#b2742d', '#587339', '#0077b3', '#632699', '#400009', '#d9a66c',
972 '#b2742d', '#587339', '#0077b3', '#632699', '#400009', '#d9a66c',
975 '#294010', '#2d4a59', '#aa00ff', '#4c131b', '#b25f00', '#5ce600',
973 '#294010', '#2d4a59', '#aa00ff', '#4c131b', '#b25f00', '#5ce600',
976 '#267399', '#a336d9', '#990014', '#664e33', '#86bf60', '#0088ff',
974 '#267399', '#a336d9', '#990014', '#664e33', '#86bf60', '#0088ff',
977 '#7700b3', '#593a16', '#073300', '#1d4b73', '#ac60bf', '#e59539',
975 '#7700b3', '#593a16', '#073300', '#1d4b73', '#ac60bf', '#e59539',
978 '#4f8c46', '#368dd9', '#5c0073'
976 '#4f8c46', '#368dd9', '#5c0073'
979 ]
977 ]
980
978
981 def rgb_to_hex_color(self, rgb_tuple):
979 def rgb_to_hex_color(self, rgb_tuple):
982 """
980 """
983 Converts an rgb_tuple passed to an hex color.
981 Converts an rgb_tuple passed to an hex color.
984
982
985 :param rgb_tuple: tuple with 3 ints represents rgb color space
983 :param rgb_tuple: tuple with 3 ints represents rgb color space
986 """
984 """
987 return '#' + ("".join(map(chr, rgb_tuple)).encode('hex'))
985 return '#' + ("".join(map(chr, rgb_tuple)).encode('hex'))
988
986
989 def email_to_int_list(self, email_str):
987 def email_to_int_list(self, email_str):
990 """
988 """
991 Get every byte of the hex digest value of email and turn it to integer.
989 Get every byte of the hex digest value of email and turn it to integer.
992 It's going to be always between 0-255
990 It's going to be always between 0-255
993 """
991 """
994 digest = md5_safe(email_str.lower())
992 digest = md5_safe(email_str.lower())
995 return [int(digest[i * 2:i * 2 + 2], 16) for i in range(16)]
993 return [int(digest[i * 2:i * 2 + 2], 16) for i in range(16)]
996
994
997 def pick_color_bank_index(self, email_str, color_bank):
995 def pick_color_bank_index(self, email_str, color_bank):
998 return self.email_to_int_list(email_str)[0] % len(color_bank)
996 return self.email_to_int_list(email_str)[0] % len(color_bank)
999
997
1000 def str2color(self, email_str):
998 def str2color(self, email_str):
1001 """
999 """
1002 Tries to map in a stable algorithm an email to color
1000 Tries to map in a stable algorithm an email to color
1003
1001
1004 :param email_str:
1002 :param email_str:
1005 """
1003 """
1006 color_bank = self.get_color_bank()
1004 color_bank = self.get_color_bank()
1007 # pick position (module it's length so we always find it in the
1005 # pick position (module it's length so we always find it in the
1008 # bank even if it's smaller than 256 values
1006 # bank even if it's smaller than 256 values
1009 pos = self.pick_color_bank_index(email_str, color_bank)
1007 pos = self.pick_color_bank_index(email_str, color_bank)
1010 return color_bank[pos]
1008 return color_bank[pos]
1011
1009
1012 def normalize_email(self, email_address):
1010 def normalize_email(self, email_address):
1013 import unicodedata
1011 import unicodedata
1014 # default host used to fill in the fake/missing email
1012 # default host used to fill in the fake/missing email
1015 default_host = u'localhost'
1013 default_host = u'localhost'
1016
1014
1017 if not email_address:
1015 if not email_address:
1018 email_address = u'%s@%s' % (User.DEFAULT_USER, default_host)
1016 email_address = u'%s@%s' % (User.DEFAULT_USER, default_host)
1019
1017
1020 email_address = safe_unicode(email_address)
1018 email_address = safe_unicode(email_address)
1021
1019
1022 if u'@' not in email_address:
1020 if u'@' not in email_address:
1023 email_address = u'%s@%s' % (email_address, default_host)
1021 email_address = u'%s@%s' % (email_address, default_host)
1024
1022
1025 if email_address.endswith(u'@'):
1023 if email_address.endswith(u'@'):
1026 email_address = u'%s%s' % (email_address, default_host)
1024 email_address = u'%s%s' % (email_address, default_host)
1027
1025
1028 email_address = unicodedata.normalize('NFKD', email_address)\
1026 email_address = unicodedata.normalize('NFKD', email_address)\
1029 .encode('ascii', 'ignore')
1027 .encode('ascii', 'ignore')
1030 return email_address
1028 return email_address
1031
1029
1032 def get_initials(self):
1030 def get_initials(self):
1033 """
1031 """
1034 Returns 2 letter initials calculated based on the input.
1032 Returns 2 letter initials calculated based on the input.
1035 The algorithm picks first given email address, and takes first letter
1033 The algorithm picks first given email address, and takes first letter
1036 of part before @, and then the first letter of server name. In case
1034 of part before @, and then the first letter of server name. In case
1037 the part before @ is in a format of `somestring.somestring2` it replaces
1035 the part before @ is in a format of `somestring.somestring2` it replaces
1038 the server letter with first letter of somestring2
1036 the server letter with first letter of somestring2
1039
1037
1040 In case function was initialized with both first and lastname, this
1038 In case function was initialized with both first and lastname, this
1041 overrides the extraction from email by first letter of the first and
1039 overrides the extraction from email by first letter of the first and
1042 last name. We add special logic to that functionality, In case Full name
1040 last name. We add special logic to that functionality, In case Full name
1043 is compound, like Guido Von Rossum, we use last part of the last name
1041 is compound, like Guido Von Rossum, we use last part of the last name
1044 (Von Rossum) picking `R`.
1042 (Von Rossum) picking `R`.
1045
1043
1046 Function also normalizes the non-ascii characters to they ascii
1044 Function also normalizes the non-ascii characters to they ascii
1047 representation, eg Δ„ => A
1045 representation, eg Δ„ => A
1048 """
1046 """
1049 import unicodedata
1047 import unicodedata
1050 # replace non-ascii to ascii
1048 # replace non-ascii to ascii
1051 first_name = unicodedata.normalize(
1049 first_name = unicodedata.normalize(
1052 'NFKD', safe_unicode(self.first_name)).encode('ascii', 'ignore')
1050 'NFKD', safe_unicode(self.first_name)).encode('ascii', 'ignore')
1053 last_name = unicodedata.normalize(
1051 last_name = unicodedata.normalize(
1054 'NFKD', safe_unicode(self.last_name)).encode('ascii', 'ignore')
1052 'NFKD', safe_unicode(self.last_name)).encode('ascii', 'ignore')
1055
1053
1056 # do NFKD encoding, and also make sure email has proper format
1054 # do NFKD encoding, and also make sure email has proper format
1057 email_address = self.normalize_email(self.email_address)
1055 email_address = self.normalize_email(self.email_address)
1058
1056
1059 # first push the email initials
1057 # first push the email initials
1060 prefix, server = email_address.split('@', 1)
1058 prefix, server = email_address.split('@', 1)
1061
1059
1062 # check if prefix is maybe a 'firstname.lastname' syntax
1060 # check if prefix is maybe a 'firstname.lastname' syntax
1063 _dot_split = prefix.rsplit('.', 1)
1061 _dot_split = prefix.rsplit('.', 1)
1064 if len(_dot_split) == 2:
1062 if len(_dot_split) == 2:
1065 initials = [_dot_split[0][0], _dot_split[1][0]]
1063 initials = [_dot_split[0][0], _dot_split[1][0]]
1066 else:
1064 else:
1067 initials = [prefix[0], server[0]]
1065 initials = [prefix[0], server[0]]
1068
1066
1069 # then try to replace either firtname or lastname
1067 # then try to replace either firtname or lastname
1070 fn_letter = (first_name or " ")[0].strip()
1068 fn_letter = (first_name or " ")[0].strip()
1071 ln_letter = (last_name.split(' ', 1)[-1] or " ")[0].strip()
1069 ln_letter = (last_name.split(' ', 1)[-1] or " ")[0].strip()
1072
1070
1073 if fn_letter:
1071 if fn_letter:
1074 initials[0] = fn_letter
1072 initials[0] = fn_letter
1075
1073
1076 if ln_letter:
1074 if ln_letter:
1077 initials[1] = ln_letter
1075 initials[1] = ln_letter
1078
1076
1079 return ''.join(initials).upper()
1077 return ''.join(initials).upper()
1080
1078
1081 def get_img_data_by_type(self, font_family, img_type):
1079 def get_img_data_by_type(self, font_family, img_type):
1082 default_user = """
1080 default_user = """
1083 <svg xmlns="http://www.w3.org/2000/svg"
1081 <svg xmlns="http://www.w3.org/2000/svg"
1084 version="1.1" x="0px" y="0px" width="{size}" height="{size}"
1082 version="1.1" x="0px" y="0px" width="{size}" height="{size}"
1085 viewBox="-15 -10 439.165 429.164"
1083 viewBox="-15 -10 439.165 429.164"
1086
1084
1087 xml:space="preserve"
1085 xml:space="preserve"
1088 style="background:{background};" >
1086 style="background:{background};" >
1089
1087
1090 <path d="M204.583,216.671c50.664,0,91.74-48.075,
1088 <path d="M204.583,216.671c50.664,0,91.74-48.075,
1091 91.74-107.378c0-82.237-41.074-107.377-91.74-107.377
1089 91.74-107.378c0-82.237-41.074-107.377-91.74-107.377
1092 c-50.668,0-91.74,25.14-91.74,107.377C112.844,
1090 c-50.668,0-91.74,25.14-91.74,107.377C112.844,
1093 168.596,153.916,216.671,
1091 168.596,153.916,216.671,
1094 204.583,216.671z" fill="{text_color}"/>
1092 204.583,216.671z" fill="{text_color}"/>
1095 <path d="M407.164,374.717L360.88,
1093 <path d="M407.164,374.717L360.88,
1096 270.454c-2.117-4.771-5.836-8.728-10.465-11.138l-71.83-37.392
1094 270.454c-2.117-4.771-5.836-8.728-10.465-11.138l-71.83-37.392
1097 c-1.584-0.823-3.502-0.663-4.926,0.415c-20.316,
1095 c-1.584-0.823-3.502-0.663-4.926,0.415c-20.316,
1098 15.366-44.203,23.488-69.076,23.488c-24.877,
1096 15.366-44.203,23.488-69.076,23.488c-24.877,
1099 0-48.762-8.122-69.078-23.488
1097 0-48.762-8.122-69.078-23.488
1100 c-1.428-1.078-3.346-1.238-4.93-0.415L58.75,
1098 c-1.428-1.078-3.346-1.238-4.93-0.415L58.75,
1101 259.316c-4.631,2.41-8.346,6.365-10.465,11.138L2.001,374.717
1099 259.316c-4.631,2.41-8.346,6.365-10.465,11.138L2.001,374.717
1102 c-3.191,7.188-2.537,15.412,1.75,22.005c4.285,
1100 c-3.191,7.188-2.537,15.412,1.75,22.005c4.285,
1103 6.592,11.537,10.526,19.4,10.526h362.861c7.863,0,15.117-3.936,
1101 6.592,11.537,10.526,19.4,10.526h362.861c7.863,0,15.117-3.936,
1104 19.402-10.527 C409.699,390.129,
1102 19.402-10.527 C409.699,390.129,
1105 410.355,381.902,407.164,374.717z" fill="{text_color}"/>
1103 410.355,381.902,407.164,374.717z" fill="{text_color}"/>
1106 </svg>""".format(
1104 </svg>""".format(
1107 size=self.size,
1105 size=self.size,
1108 background='#979797', # @grey4
1106 background='#979797', # @grey4
1109 text_color=self.text_color,
1107 text_color=self.text_color,
1110 font_family=font_family)
1108 font_family=font_family)
1111
1109
1112 return {
1110 return {
1113 "default_user": default_user
1111 "default_user": default_user
1114 }[img_type]
1112 }[img_type]
1115
1113
1116 def get_img_data(self, svg_type=None):
1114 def get_img_data(self, svg_type=None):
1117 """
1115 """
1118 generates the svg metadata for image
1116 generates the svg metadata for image
1119 """
1117 """
1120
1118
1121 font_family = ','.join([
1119 font_family = ','.join([
1122 'proximanovaregular',
1120 'proximanovaregular',
1123 'Proxima Nova Regular',
1121 'Proxima Nova Regular',
1124 'Proxima Nova',
1122 'Proxima Nova',
1125 'Arial',
1123 'Arial',
1126 'Lucida Grande',
1124 'Lucida Grande',
1127 'sans-serif'
1125 'sans-serif'
1128 ])
1126 ])
1129 if svg_type:
1127 if svg_type:
1130 return self.get_img_data_by_type(font_family, svg_type)
1128 return self.get_img_data_by_type(font_family, svg_type)
1131
1129
1132 initials = self.get_initials()
1130 initials = self.get_initials()
1133 img_data = """
1131 img_data = """
1134 <svg xmlns="http://www.w3.org/2000/svg" pointer-events="none"
1132 <svg xmlns="http://www.w3.org/2000/svg" pointer-events="none"
1135 width="{size}" height="{size}"
1133 width="{size}" height="{size}"
1136 style="width: 100%; height: 100%; background-color: {background}"
1134 style="width: 100%; height: 100%; background-color: {background}"
1137 viewBox="0 0 {size} {size}">
1135 viewBox="0 0 {size} {size}">
1138 <text text-anchor="middle" y="50%" x="50%" dy="0.35em"
1136 <text text-anchor="middle" y="50%" x="50%" dy="0.35em"
1139 pointer-events="auto" fill="{text_color}"
1137 pointer-events="auto" fill="{text_color}"
1140 font-family="{font_family}"
1138 font-family="{font_family}"
1141 style="font-weight: 400; font-size: {f_size}px;">{text}
1139 style="font-weight: 400; font-size: {f_size}px;">{text}
1142 </text>
1140 </text>
1143 </svg>""".format(
1141 </svg>""".format(
1144 size=self.size,
1142 size=self.size,
1145 f_size=self.size/1.85, # scale the text inside the box nicely
1143 f_size=self.size/1.85, # scale the text inside the box nicely
1146 background=self.background,
1144 background=self.background,
1147 text_color=self.text_color,
1145 text_color=self.text_color,
1148 text=initials.upper(),
1146 text=initials.upper(),
1149 font_family=font_family)
1147 font_family=font_family)
1150
1148
1151 return img_data
1149 return img_data
1152
1150
1153 def generate_svg(self, svg_type=None):
1151 def generate_svg(self, svg_type=None):
1154 img_data = self.get_img_data(svg_type)
1152 img_data = self.get_img_data(svg_type)
1155 return "data:image/svg+xml;base64,%s" % img_data.encode('base64')
1153 return "data:image/svg+xml;base64,%s" % img_data.encode('base64')
1156
1154
1157
1155
1158 def initials_gravatar(email_address, first_name, last_name, size=30):
1156 def initials_gravatar(email_address, first_name, last_name, size=30):
1159 svg_type = None
1157 svg_type = None
1160 if email_address == User.DEFAULT_USER_EMAIL:
1158 if email_address == User.DEFAULT_USER_EMAIL:
1161 svg_type = 'default_user'
1159 svg_type = 'default_user'
1162 klass = InitialsGravatar(email_address, first_name, last_name, size)
1160 klass = InitialsGravatar(email_address, first_name, last_name, size)
1163 return klass.generate_svg(svg_type=svg_type)
1161 return klass.generate_svg(svg_type=svg_type)
1164
1162
1165
1163
1166 def gravatar_url(email_address, size=30):
1164 def gravatar_url(email_address, size=30):
1167 # doh, we need to re-import those to mock it later
1165 # doh, we need to re-import those to mock it later
1168 from pylons import tmpl_context as c
1166 from pylons import tmpl_context as c
1169
1167
1170 _use_gravatar = c.visual.use_gravatar
1168 _use_gravatar = c.visual.use_gravatar
1171 _gravatar_url = c.visual.gravatar_url or User.DEFAULT_GRAVATAR_URL
1169 _gravatar_url = c.visual.gravatar_url or User.DEFAULT_GRAVATAR_URL
1172
1170
1173 email_address = email_address or User.DEFAULT_USER_EMAIL
1171 email_address = email_address or User.DEFAULT_USER_EMAIL
1174 if isinstance(email_address, unicode):
1172 if isinstance(email_address, unicode):
1175 # hashlib crashes on unicode items
1173 # hashlib crashes on unicode items
1176 email_address = safe_str(email_address)
1174 email_address = safe_str(email_address)
1177
1175
1178 # empty email or default user
1176 # empty email or default user
1179 if not email_address or email_address == User.DEFAULT_USER_EMAIL:
1177 if not email_address or email_address == User.DEFAULT_USER_EMAIL:
1180 return initials_gravatar(User.DEFAULT_USER_EMAIL, '', '', size=size)
1178 return initials_gravatar(User.DEFAULT_USER_EMAIL, '', '', size=size)
1181
1179
1182 if _use_gravatar:
1180 if _use_gravatar:
1183 # TODO: Disuse pyramid thread locals. Think about another solution to
1181 # TODO: Disuse pyramid thread locals. Think about another solution to
1184 # get the host and schema here.
1182 # get the host and schema here.
1185 request = get_current_request()
1183 request = get_current_request()
1186 tmpl = safe_str(_gravatar_url)
1184 tmpl = safe_str(_gravatar_url)
1187 tmpl = tmpl.replace('{email}', email_address)\
1185 tmpl = tmpl.replace('{email}', email_address)\
1188 .replace('{md5email}', md5_safe(email_address.lower())) \
1186 .replace('{md5email}', md5_safe(email_address.lower())) \
1189 .replace('{netloc}', request.host)\
1187 .replace('{netloc}', request.host)\
1190 .replace('{scheme}', request.scheme)\
1188 .replace('{scheme}', request.scheme)\
1191 .replace('{size}', safe_str(size))
1189 .replace('{size}', safe_str(size))
1192 return tmpl
1190 return tmpl
1193 else:
1191 else:
1194 return initials_gravatar(email_address, '', '', size=size)
1192 return initials_gravatar(email_address, '', '', size=size)
1195
1193
1196
1194
1197 class Page(_Page):
1195 class Page(_Page):
1198 """
1196 """
1199 Custom pager to match rendering style with paginator
1197 Custom pager to match rendering style with paginator
1200 """
1198 """
1201
1199
1202 def _get_pos(self, cur_page, max_page, items):
1200 def _get_pos(self, cur_page, max_page, items):
1203 edge = (items / 2) + 1
1201 edge = (items / 2) + 1
1204 if (cur_page <= edge):
1202 if (cur_page <= edge):
1205 radius = max(items / 2, items - cur_page)
1203 radius = max(items / 2, items - cur_page)
1206 elif (max_page - cur_page) < edge:
1204 elif (max_page - cur_page) < edge:
1207 radius = (items - 1) - (max_page - cur_page)
1205 radius = (items - 1) - (max_page - cur_page)
1208 else:
1206 else:
1209 radius = items / 2
1207 radius = items / 2
1210
1208
1211 left = max(1, (cur_page - (radius)))
1209 left = max(1, (cur_page - (radius)))
1212 right = min(max_page, cur_page + (radius))
1210 right = min(max_page, cur_page + (radius))
1213 return left, cur_page, right
1211 return left, cur_page, right
1214
1212
1215 def _range(self, regexp_match):
1213 def _range(self, regexp_match):
1216 """
1214 """
1217 Return range of linked pages (e.g. '1 2 [3] 4 5 6 7 8').
1215 Return range of linked pages (e.g. '1 2 [3] 4 5 6 7 8').
1218
1216
1219 Arguments:
1217 Arguments:
1220
1218
1221 regexp_match
1219 regexp_match
1222 A "re" (regular expressions) match object containing the
1220 A "re" (regular expressions) match object containing the
1223 radius of linked pages around the current page in
1221 radius of linked pages around the current page in
1224 regexp_match.group(1) as a string
1222 regexp_match.group(1) as a string
1225
1223
1226 This function is supposed to be called as a callable in
1224 This function is supposed to be called as a callable in
1227 re.sub.
1225 re.sub.
1228
1226
1229 """
1227 """
1230 radius = int(regexp_match.group(1))
1228 radius = int(regexp_match.group(1))
1231
1229
1232 # Compute the first and last page number within the radius
1230 # Compute the first and last page number within the radius
1233 # e.g. '1 .. 5 6 [7] 8 9 .. 12'
1231 # e.g. '1 .. 5 6 [7] 8 9 .. 12'
1234 # -> leftmost_page = 5
1232 # -> leftmost_page = 5
1235 # -> rightmost_page = 9
1233 # -> rightmost_page = 9
1236 leftmost_page, _cur, rightmost_page = self._get_pos(self.page,
1234 leftmost_page, _cur, rightmost_page = self._get_pos(self.page,
1237 self.last_page,
1235 self.last_page,
1238 (radius * 2) + 1)
1236 (radius * 2) + 1)
1239 nav_items = []
1237 nav_items = []
1240
1238
1241 # Create a link to the first page (unless we are on the first page
1239 # Create a link to the first page (unless we are on the first page
1242 # or there would be no need to insert '..' spacers)
1240 # or there would be no need to insert '..' spacers)
1243 if self.page != self.first_page and self.first_page < leftmost_page:
1241 if self.page != self.first_page and self.first_page < leftmost_page:
1244 nav_items.append(self._pagerlink(self.first_page, self.first_page))
1242 nav_items.append(self._pagerlink(self.first_page, self.first_page))
1245
1243
1246 # Insert dots if there are pages between the first page
1244 # Insert dots if there are pages between the first page
1247 # and the currently displayed page range
1245 # and the currently displayed page range
1248 if leftmost_page - self.first_page > 1:
1246 if leftmost_page - self.first_page > 1:
1249 # Wrap in a SPAN tag if nolink_attr is set
1247 # Wrap in a SPAN tag if nolink_attr is set
1250 text = '..'
1248 text = '..'
1251 if self.dotdot_attr:
1249 if self.dotdot_attr:
1252 text = HTML.span(c=text, **self.dotdot_attr)
1250 text = HTML.span(c=text, **self.dotdot_attr)
1253 nav_items.append(text)
1251 nav_items.append(text)
1254
1252
1255 for thispage in xrange(leftmost_page, rightmost_page + 1):
1253 for thispage in xrange(leftmost_page, rightmost_page + 1):
1256 # Hilight the current page number and do not use a link
1254 # Hilight the current page number and do not use a link
1257 if thispage == self.page:
1255 if thispage == self.page:
1258 text = '%s' % (thispage,)
1256 text = '%s' % (thispage,)
1259 # Wrap in a SPAN tag if nolink_attr is set
1257 # Wrap in a SPAN tag if nolink_attr is set
1260 if self.curpage_attr:
1258 if self.curpage_attr:
1261 text = HTML.span(c=text, **self.curpage_attr)
1259 text = HTML.span(c=text, **self.curpage_attr)
1262 nav_items.append(text)
1260 nav_items.append(text)
1263 # Otherwise create just a link to that page
1261 # Otherwise create just a link to that page
1264 else:
1262 else:
1265 text = '%s' % (thispage,)
1263 text = '%s' % (thispage,)
1266 nav_items.append(self._pagerlink(thispage, text))
1264 nav_items.append(self._pagerlink(thispage, text))
1267
1265
1268 # Insert dots if there are pages between the displayed
1266 # Insert dots if there are pages between the displayed
1269 # page numbers and the end of the page range
1267 # page numbers and the end of the page range
1270 if self.last_page - rightmost_page > 1:
1268 if self.last_page - rightmost_page > 1:
1271 text = '..'
1269 text = '..'
1272 # Wrap in a SPAN tag if nolink_attr is set
1270 # Wrap in a SPAN tag if nolink_attr is set
1273 if self.dotdot_attr:
1271 if self.dotdot_attr:
1274 text = HTML.span(c=text, **self.dotdot_attr)
1272 text = HTML.span(c=text, **self.dotdot_attr)
1275 nav_items.append(text)
1273 nav_items.append(text)
1276
1274
1277 # Create a link to the very last page (unless we are on the last
1275 # Create a link to the very last page (unless we are on the last
1278 # page or there would be no need to insert '..' spacers)
1276 # page or there would be no need to insert '..' spacers)
1279 if self.page != self.last_page and rightmost_page < self.last_page:
1277 if self.page != self.last_page and rightmost_page < self.last_page:
1280 nav_items.append(self._pagerlink(self.last_page, self.last_page))
1278 nav_items.append(self._pagerlink(self.last_page, self.last_page))
1281
1279
1282 ## prerender links
1280 ## prerender links
1283 #_page_link = url.current()
1281 #_page_link = url.current()
1284 #nav_items.append(literal('<link rel="prerender" href="%s?page=%s">' % (_page_link, str(int(self.page)+1))))
1282 #nav_items.append(literal('<link rel="prerender" href="%s?page=%s">' % (_page_link, str(int(self.page)+1))))
1285 #nav_items.append(literal('<link rel="prefetch" href="%s?page=%s">' % (_page_link, str(int(self.page)+1))))
1283 #nav_items.append(literal('<link rel="prefetch" href="%s?page=%s">' % (_page_link, str(int(self.page)+1))))
1286 return self.separator.join(nav_items)
1284 return self.separator.join(nav_items)
1287
1285
1288 def pager(self, format='~2~', page_param='page', partial_param='partial',
1286 def pager(self, format='~2~', page_param='page', partial_param='partial',
1289 show_if_single_page=False, separator=' ', onclick=None,
1287 show_if_single_page=False, separator=' ', onclick=None,
1290 symbol_first='<<', symbol_last='>>',
1288 symbol_first='<<', symbol_last='>>',
1291 symbol_previous='<', symbol_next='>',
1289 symbol_previous='<', symbol_next='>',
1292 link_attr={'class': 'pager_link', 'rel': 'prerender'},
1290 link_attr={'class': 'pager_link', 'rel': 'prerender'},
1293 curpage_attr={'class': 'pager_curpage'},
1291 curpage_attr={'class': 'pager_curpage'},
1294 dotdot_attr={'class': 'pager_dotdot'}, **kwargs):
1292 dotdot_attr={'class': 'pager_dotdot'}, **kwargs):
1295
1293
1296 self.curpage_attr = curpage_attr
1294 self.curpage_attr = curpage_attr
1297 self.separator = separator
1295 self.separator = separator
1298 self.pager_kwargs = kwargs
1296 self.pager_kwargs = kwargs
1299 self.page_param = page_param
1297 self.page_param = page_param
1300 self.partial_param = partial_param
1298 self.partial_param = partial_param
1301 self.onclick = onclick
1299 self.onclick = onclick
1302 self.link_attr = link_attr
1300 self.link_attr = link_attr
1303 self.dotdot_attr = dotdot_attr
1301 self.dotdot_attr = dotdot_attr
1304
1302
1305 # Don't show navigator if there is no more than one page
1303 # Don't show navigator if there is no more than one page
1306 if self.page_count == 0 or (self.page_count == 1 and not show_if_single_page):
1304 if self.page_count == 0 or (self.page_count == 1 and not show_if_single_page):
1307 return ''
1305 return ''
1308
1306
1309 from string import Template
1307 from string import Template
1310 # Replace ~...~ in token format by range of pages
1308 # Replace ~...~ in token format by range of pages
1311 result = re.sub(r'~(\d+)~', self._range, format)
1309 result = re.sub(r'~(\d+)~', self._range, format)
1312
1310
1313 # Interpolate '%' variables
1311 # Interpolate '%' variables
1314 result = Template(result).safe_substitute({
1312 result = Template(result).safe_substitute({
1315 'first_page': self.first_page,
1313 'first_page': self.first_page,
1316 'last_page': self.last_page,
1314 'last_page': self.last_page,
1317 'page': self.page,
1315 'page': self.page,
1318 'page_count': self.page_count,
1316 'page_count': self.page_count,
1319 'items_per_page': self.items_per_page,
1317 'items_per_page': self.items_per_page,
1320 'first_item': self.first_item,
1318 'first_item': self.first_item,
1321 'last_item': self.last_item,
1319 'last_item': self.last_item,
1322 'item_count': self.item_count,
1320 'item_count': self.item_count,
1323 'link_first': self.page > self.first_page and \
1321 'link_first': self.page > self.first_page and \
1324 self._pagerlink(self.first_page, symbol_first) or '',
1322 self._pagerlink(self.first_page, symbol_first) or '',
1325 'link_last': self.page < self.last_page and \
1323 'link_last': self.page < self.last_page and \
1326 self._pagerlink(self.last_page, symbol_last) or '',
1324 self._pagerlink(self.last_page, symbol_last) or '',
1327 'link_previous': self.previous_page and \
1325 'link_previous': self.previous_page and \
1328 self._pagerlink(self.previous_page, symbol_previous) \
1326 self._pagerlink(self.previous_page, symbol_previous) \
1329 or HTML.span(symbol_previous, class_="pg-previous disabled"),
1327 or HTML.span(symbol_previous, class_="pg-previous disabled"),
1330 'link_next': self.next_page and \
1328 'link_next': self.next_page and \
1331 self._pagerlink(self.next_page, symbol_next) \
1329 self._pagerlink(self.next_page, symbol_next) \
1332 or HTML.span(symbol_next, class_="pg-next disabled")
1330 or HTML.span(symbol_next, class_="pg-next disabled")
1333 })
1331 })
1334
1332
1335 return literal(result)
1333 return literal(result)
1336
1334
1337
1335
1338 #==============================================================================
1336 #==============================================================================
1339 # REPO PAGER, PAGER FOR REPOSITORY
1337 # REPO PAGER, PAGER FOR REPOSITORY
1340 #==============================================================================
1338 #==============================================================================
1341 class RepoPage(Page):
1339 class RepoPage(Page):
1342
1340
1343 def __init__(self, collection, page=1, items_per_page=20,
1341 def __init__(self, collection, page=1, items_per_page=20,
1344 item_count=None, url=None, **kwargs):
1342 item_count=None, url=None, **kwargs):
1345
1343
1346 """Create a "RepoPage" instance. special pager for paging
1344 """Create a "RepoPage" instance. special pager for paging
1347 repository
1345 repository
1348 """
1346 """
1349 self._url_generator = url
1347 self._url_generator = url
1350
1348
1351 # Safe the kwargs class-wide so they can be used in the pager() method
1349 # Safe the kwargs class-wide so they can be used in the pager() method
1352 self.kwargs = kwargs
1350 self.kwargs = kwargs
1353
1351
1354 # Save a reference to the collection
1352 # Save a reference to the collection
1355 self.original_collection = collection
1353 self.original_collection = collection
1356
1354
1357 self.collection = collection
1355 self.collection = collection
1358
1356
1359 # The self.page is the number of the current page.
1357 # The self.page is the number of the current page.
1360 # The first page has the number 1!
1358 # The first page has the number 1!
1361 try:
1359 try:
1362 self.page = int(page) # make it int() if we get it as a string
1360 self.page = int(page) # make it int() if we get it as a string
1363 except (ValueError, TypeError):
1361 except (ValueError, TypeError):
1364 self.page = 1
1362 self.page = 1
1365
1363
1366 self.items_per_page = items_per_page
1364 self.items_per_page = items_per_page
1367
1365
1368 # Unless the user tells us how many items the collections has
1366 # Unless the user tells us how many items the collections has
1369 # we calculate that ourselves.
1367 # we calculate that ourselves.
1370 if item_count is not None:
1368 if item_count is not None:
1371 self.item_count = item_count
1369 self.item_count = item_count
1372 else:
1370 else:
1373 self.item_count = len(self.collection)
1371 self.item_count = len(self.collection)
1374
1372
1375 # Compute the number of the first and last available page
1373 # Compute the number of the first and last available page
1376 if self.item_count > 0:
1374 if self.item_count > 0:
1377 self.first_page = 1
1375 self.first_page = 1
1378 self.page_count = int(math.ceil(float(self.item_count) /
1376 self.page_count = int(math.ceil(float(self.item_count) /
1379 self.items_per_page))
1377 self.items_per_page))
1380 self.last_page = self.first_page + self.page_count - 1
1378 self.last_page = self.first_page + self.page_count - 1
1381
1379
1382 # Make sure that the requested page number is the range of
1380 # Make sure that the requested page number is the range of
1383 # valid pages
1381 # valid pages
1384 if self.page > self.last_page:
1382 if self.page > self.last_page:
1385 self.page = self.last_page
1383 self.page = self.last_page
1386 elif self.page < self.first_page:
1384 elif self.page < self.first_page:
1387 self.page = self.first_page
1385 self.page = self.first_page
1388
1386
1389 # Note: the number of items on this page can be less than
1387 # Note: the number of items on this page can be less than
1390 # items_per_page if the last page is not full
1388 # items_per_page if the last page is not full
1391 self.first_item = max(0, (self.item_count) - (self.page *
1389 self.first_item = max(0, (self.item_count) - (self.page *
1392 items_per_page))
1390 items_per_page))
1393 self.last_item = ((self.item_count - 1) - items_per_page *
1391 self.last_item = ((self.item_count - 1) - items_per_page *
1394 (self.page - 1))
1392 (self.page - 1))
1395
1393
1396 self.items = list(self.collection[self.first_item:self.last_item + 1])
1394 self.items = list(self.collection[self.first_item:self.last_item + 1])
1397
1395
1398 # Links to previous and next page
1396 # Links to previous and next page
1399 if self.page > self.first_page:
1397 if self.page > self.first_page:
1400 self.previous_page = self.page - 1
1398 self.previous_page = self.page - 1
1401 else:
1399 else:
1402 self.previous_page = None
1400 self.previous_page = None
1403
1401
1404 if self.page < self.last_page:
1402 if self.page < self.last_page:
1405 self.next_page = self.page + 1
1403 self.next_page = self.page + 1
1406 else:
1404 else:
1407 self.next_page = None
1405 self.next_page = None
1408
1406
1409 # No items available
1407 # No items available
1410 else:
1408 else:
1411 self.first_page = None
1409 self.first_page = None
1412 self.page_count = 0
1410 self.page_count = 0
1413 self.last_page = None
1411 self.last_page = None
1414 self.first_item = None
1412 self.first_item = None
1415 self.last_item = None
1413 self.last_item = None
1416 self.previous_page = None
1414 self.previous_page = None
1417 self.next_page = None
1415 self.next_page = None
1418 self.items = []
1416 self.items = []
1419
1417
1420 # This is a subclass of the 'list' type. Initialise the list now.
1418 # This is a subclass of the 'list' type. Initialise the list now.
1421 list.__init__(self, reversed(self.items))
1419 list.__init__(self, reversed(self.items))
1422
1420
1423
1421
1424 def changed_tooltip(nodes):
1422 def changed_tooltip(nodes):
1425 """
1423 """
1426 Generates a html string for changed nodes in commit page.
1424 Generates a html string for changed nodes in commit page.
1427 It limits the output to 30 entries
1425 It limits the output to 30 entries
1428
1426
1429 :param nodes: LazyNodesGenerator
1427 :param nodes: LazyNodesGenerator
1430 """
1428 """
1431 if nodes:
1429 if nodes:
1432 pref = ': <br/> '
1430 pref = ': <br/> '
1433 suf = ''
1431 suf = ''
1434 if len(nodes) > 30:
1432 if len(nodes) > 30:
1435 suf = '<br/>' + _(' and %s more') % (len(nodes) - 30)
1433 suf = '<br/>' + _(' and %s more') % (len(nodes) - 30)
1436 return literal(pref + '<br/> '.join([safe_unicode(x.path)
1434 return literal(pref + '<br/> '.join([safe_unicode(x.path)
1437 for x in nodes[:30]]) + suf)
1435 for x in nodes[:30]]) + suf)
1438 else:
1436 else:
1439 return ': ' + _('No Files')
1437 return ': ' + _('No Files')
1440
1438
1441
1439
1442 def breadcrumb_repo_link(repo):
1440 def breadcrumb_repo_link(repo):
1443 """
1441 """
1444 Makes a breadcrumbs path link to repo
1442 Makes a breadcrumbs path link to repo
1445
1443
1446 ex::
1444 ex::
1447 group >> subgroup >> repo
1445 group >> subgroup >> repo
1448
1446
1449 :param repo: a Repository instance
1447 :param repo: a Repository instance
1450 """
1448 """
1451
1449
1452 path = [
1450 path = [
1453 link_to(group.name, url('repo_group_home', group_name=group.group_name))
1451 link_to(group.name, url('repo_group_home', group_name=group.group_name))
1454 for group in repo.groups_with_parents
1452 for group in repo.groups_with_parents
1455 ] + [
1453 ] + [
1456 link_to(repo.just_name, url('summary_home', repo_name=repo.repo_name))
1454 link_to(repo.just_name, url('summary_home', repo_name=repo.repo_name))
1457 ]
1455 ]
1458
1456
1459 return literal(' &raquo; '.join(path))
1457 return literal(' &raquo; '.join(path))
1460
1458
1461
1459
1462 def format_byte_size_binary(file_size):
1460 def format_byte_size_binary(file_size):
1463 """
1461 """
1464 Formats file/folder sizes to standard.
1462 Formats file/folder sizes to standard.
1465 """
1463 """
1466 formatted_size = format_byte_size(file_size, binary=True)
1464 formatted_size = format_byte_size(file_size, binary=True)
1467 return formatted_size
1465 return formatted_size
1468
1466
1469
1467
1470 def fancy_file_stats(stats):
1468 def fancy_file_stats(stats):
1471 """
1469 """
1472 Displays a fancy two colored bar for number of added/deleted
1470 Displays a fancy two colored bar for number of added/deleted
1473 lines of code on file
1471 lines of code on file
1474
1472
1475 :param stats: two element list of added/deleted lines of code
1473 :param stats: two element list of added/deleted lines of code
1476 """
1474 """
1477 from rhodecode.lib.diffs import NEW_FILENODE, DEL_FILENODE, \
1475 from rhodecode.lib.diffs import NEW_FILENODE, DEL_FILENODE, \
1478 MOD_FILENODE, RENAMED_FILENODE, CHMOD_FILENODE, BIN_FILENODE
1476 MOD_FILENODE, RENAMED_FILENODE, CHMOD_FILENODE, BIN_FILENODE
1479
1477
1480 def cgen(l_type, a_v, d_v):
1478 def cgen(l_type, a_v, d_v):
1481 mapping = {'tr': 'top-right-rounded-corner-mid',
1479 mapping = {'tr': 'top-right-rounded-corner-mid',
1482 'tl': 'top-left-rounded-corner-mid',
1480 'tl': 'top-left-rounded-corner-mid',
1483 'br': 'bottom-right-rounded-corner-mid',
1481 'br': 'bottom-right-rounded-corner-mid',
1484 'bl': 'bottom-left-rounded-corner-mid'}
1482 'bl': 'bottom-left-rounded-corner-mid'}
1485 map_getter = lambda x: mapping[x]
1483 map_getter = lambda x: mapping[x]
1486
1484
1487 if l_type == 'a' and d_v:
1485 if l_type == 'a' and d_v:
1488 #case when added and deleted are present
1486 #case when added and deleted are present
1489 return ' '.join(map(map_getter, ['tl', 'bl']))
1487 return ' '.join(map(map_getter, ['tl', 'bl']))
1490
1488
1491 if l_type == 'a' and not d_v:
1489 if l_type == 'a' and not d_v:
1492 return ' '.join(map(map_getter, ['tr', 'br', 'tl', 'bl']))
1490 return ' '.join(map(map_getter, ['tr', 'br', 'tl', 'bl']))
1493
1491
1494 if l_type == 'd' and a_v:
1492 if l_type == 'd' and a_v:
1495 return ' '.join(map(map_getter, ['tr', 'br']))
1493 return ' '.join(map(map_getter, ['tr', 'br']))
1496
1494
1497 if l_type == 'd' and not a_v:
1495 if l_type == 'd' and not a_v:
1498 return ' '.join(map(map_getter, ['tr', 'br', 'tl', 'bl']))
1496 return ' '.join(map(map_getter, ['tr', 'br', 'tl', 'bl']))
1499
1497
1500 a, d = stats['added'], stats['deleted']
1498 a, d = stats['added'], stats['deleted']
1501 width = 100
1499 width = 100
1502
1500
1503 if stats['binary']: # binary operations like chmod/rename etc
1501 if stats['binary']: # binary operations like chmod/rename etc
1504 lbl = []
1502 lbl = []
1505 bin_op = 0 # undefined
1503 bin_op = 0 # undefined
1506
1504
1507 # prefix with bin for binary files
1505 # prefix with bin for binary files
1508 if BIN_FILENODE in stats['ops']:
1506 if BIN_FILENODE in stats['ops']:
1509 lbl += ['bin']
1507 lbl += ['bin']
1510
1508
1511 if NEW_FILENODE in stats['ops']:
1509 if NEW_FILENODE in stats['ops']:
1512 lbl += [_('new file')]
1510 lbl += [_('new file')]
1513 bin_op = NEW_FILENODE
1511 bin_op = NEW_FILENODE
1514 elif MOD_FILENODE in stats['ops']:
1512 elif MOD_FILENODE in stats['ops']:
1515 lbl += [_('mod')]
1513 lbl += [_('mod')]
1516 bin_op = MOD_FILENODE
1514 bin_op = MOD_FILENODE
1517 elif DEL_FILENODE in stats['ops']:
1515 elif DEL_FILENODE in stats['ops']:
1518 lbl += [_('del')]
1516 lbl += [_('del')]
1519 bin_op = DEL_FILENODE
1517 bin_op = DEL_FILENODE
1520 elif RENAMED_FILENODE in stats['ops']:
1518 elif RENAMED_FILENODE in stats['ops']:
1521 lbl += [_('rename')]
1519 lbl += [_('rename')]
1522 bin_op = RENAMED_FILENODE
1520 bin_op = RENAMED_FILENODE
1523
1521
1524 # chmod can go with other operations, so we add a + to lbl if needed
1522 # chmod can go with other operations, so we add a + to lbl if needed
1525 if CHMOD_FILENODE in stats['ops']:
1523 if CHMOD_FILENODE in stats['ops']:
1526 lbl += [_('chmod')]
1524 lbl += [_('chmod')]
1527 if bin_op == 0:
1525 if bin_op == 0:
1528 bin_op = CHMOD_FILENODE
1526 bin_op = CHMOD_FILENODE
1529
1527
1530 lbl = '+'.join(lbl)
1528 lbl = '+'.join(lbl)
1531 b_a = '<div class="bin bin%s %s" style="width:100%%">%s</div>' \
1529 b_a = '<div class="bin bin%s %s" style="width:100%%">%s</div>' \
1532 % (bin_op, cgen('a', a_v='', d_v=0), lbl)
1530 % (bin_op, cgen('a', a_v='', d_v=0), lbl)
1533 b_d = '<div class="bin bin1" style="width:0%%"></div>'
1531 b_d = '<div class="bin bin1" style="width:0%%"></div>'
1534 return literal('<div style="width:%spx">%s%s</div>' % (width, b_a, b_d))
1532 return literal('<div style="width:%spx">%s%s</div>' % (width, b_a, b_d))
1535
1533
1536 t = stats['added'] + stats['deleted']
1534 t = stats['added'] + stats['deleted']
1537 unit = float(width) / (t or 1)
1535 unit = float(width) / (t or 1)
1538
1536
1539 # needs > 9% of width to be visible or 0 to be hidden
1537 # needs > 9% of width to be visible or 0 to be hidden
1540 a_p = max(9, unit * a) if a > 0 else 0
1538 a_p = max(9, unit * a) if a > 0 else 0
1541 d_p = max(9, unit * d) if d > 0 else 0
1539 d_p = max(9, unit * d) if d > 0 else 0
1542 p_sum = a_p + d_p
1540 p_sum = a_p + d_p
1543
1541
1544 if p_sum > width:
1542 if p_sum > width:
1545 #adjust the percentage to be == 100% since we adjusted to 9
1543 #adjust the percentage to be == 100% since we adjusted to 9
1546 if a_p > d_p:
1544 if a_p > d_p:
1547 a_p = a_p - (p_sum - width)
1545 a_p = a_p - (p_sum - width)
1548 else:
1546 else:
1549 d_p = d_p - (p_sum - width)
1547 d_p = d_p - (p_sum - width)
1550
1548
1551 a_v = a if a > 0 else ''
1549 a_v = a if a > 0 else ''
1552 d_v = d if d > 0 else ''
1550 d_v = d if d > 0 else ''
1553
1551
1554 d_a = '<div class="added %s" style="width:%s%%">%s</div>' % (
1552 d_a = '<div class="added %s" style="width:%s%%">%s</div>' % (
1555 cgen('a', a_v, d_v), a_p, a_v
1553 cgen('a', a_v, d_v), a_p, a_v
1556 )
1554 )
1557 d_d = '<div class="deleted %s" style="width:%s%%">%s</div>' % (
1555 d_d = '<div class="deleted %s" style="width:%s%%">%s</div>' % (
1558 cgen('d', a_v, d_v), d_p, d_v
1556 cgen('d', a_v, d_v), d_p, d_v
1559 )
1557 )
1560 return literal('<div style="width:%spx">%s%s</div>' % (width, d_a, d_d))
1558 return literal('<div style="width:%spx">%s%s</div>' % (width, d_a, d_d))
1561
1559
1562
1560
1563 def urlify_text(text_, safe=True):
1561 def urlify_text(text_, safe=True):
1564 """
1562 """
1565 Extrac urls from text and make html links out of them
1563 Extrac urls from text and make html links out of them
1566
1564
1567 :param text_:
1565 :param text_:
1568 """
1566 """
1569
1567
1570 url_pat = re.compile(r'''(http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@#.&+]'''
1568 url_pat = re.compile(r'''(http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@#.&+]'''
1571 '''|[!*\(\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+)''')
1569 '''|[!*\(\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+)''')
1572
1570
1573 def url_func(match_obj):
1571 def url_func(match_obj):
1574 url_full = match_obj.groups()[0]
1572 url_full = match_obj.groups()[0]
1575 return '<a href="%(url)s">%(url)s</a>' % ({'url': url_full})
1573 return '<a href="%(url)s">%(url)s</a>' % ({'url': url_full})
1576 _newtext = url_pat.sub(url_func, text_)
1574 _newtext = url_pat.sub(url_func, text_)
1577 if safe:
1575 if safe:
1578 return literal(_newtext)
1576 return literal(_newtext)
1579 return _newtext
1577 return _newtext
1580
1578
1581
1579
1582 def urlify_commits(text_, repository):
1580 def urlify_commits(text_, repository):
1583 """
1581 """
1584 Extract commit ids from text and make link from them
1582 Extract commit ids from text and make link from them
1585
1583
1586 :param text_:
1584 :param text_:
1587 :param repository: repo name to build the URL with
1585 :param repository: repo name to build the URL with
1588 """
1586 """
1589 from pylons import url # doh, we need to re-import url to mock it later
1587 from pylons import url # doh, we need to re-import url to mock it later
1590 URL_PAT = re.compile(r'(^|\s)([0-9a-fA-F]{12,40})($|\s)')
1588 URL_PAT = re.compile(r'(^|\s)([0-9a-fA-F]{12,40})($|\s)')
1591
1589
1592 def url_func(match_obj):
1590 def url_func(match_obj):
1593 commit_id = match_obj.groups()[1]
1591 commit_id = match_obj.groups()[1]
1594 pref = match_obj.groups()[0]
1592 pref = match_obj.groups()[0]
1595 suf = match_obj.groups()[2]
1593 suf = match_obj.groups()[2]
1596
1594
1597 tmpl = (
1595 tmpl = (
1598 '%(pref)s<a class="%(cls)s" href="%(url)s">'
1596 '%(pref)s<a class="%(cls)s" href="%(url)s">'
1599 '%(commit_id)s</a>%(suf)s'
1597 '%(commit_id)s</a>%(suf)s'
1600 )
1598 )
1601 return tmpl % {
1599 return tmpl % {
1602 'pref': pref,
1600 'pref': pref,
1603 'cls': 'revision-link',
1601 'cls': 'revision-link',
1604 'url': url('changeset_home', repo_name=repository,
1602 'url': url('changeset_home', repo_name=repository,
1605 revision=commit_id),
1603 revision=commit_id),
1606 'commit_id': commit_id,
1604 'commit_id': commit_id,
1607 'suf': suf
1605 'suf': suf
1608 }
1606 }
1609
1607
1610 newtext = URL_PAT.sub(url_func, text_)
1608 newtext = URL_PAT.sub(url_func, text_)
1611
1609
1612 return newtext
1610 return newtext
1613
1611
1614
1612
1615 def _process_url_func(match_obj, repo_name, uid, entry):
1613 def _process_url_func(match_obj, repo_name, uid, entry):
1616 pref = ''
1614 pref = ''
1617 if match_obj.group().startswith(' '):
1615 if match_obj.group().startswith(' '):
1618 pref = ' '
1616 pref = ' '
1619
1617
1620 issue_id = ''.join(match_obj.groups())
1618 issue_id = ''.join(match_obj.groups())
1621 tmpl = (
1619 tmpl = (
1622 '%(pref)s<a class="%(cls)s" href="%(url)s">'
1620 '%(pref)s<a class="%(cls)s" href="%(url)s">'
1623 '%(issue-prefix)s%(id-repr)s'
1621 '%(issue-prefix)s%(id-repr)s'
1624 '</a>')
1622 '</a>')
1625
1623
1626 (repo_name_cleaned,
1624 (repo_name_cleaned,
1627 parent_group_name) = RepoGroupModel().\
1625 parent_group_name) = RepoGroupModel().\
1628 _get_group_name_and_parent(repo_name)
1626 _get_group_name_and_parent(repo_name)
1629
1627
1630 # variables replacement
1628 # variables replacement
1631 named_vars = {
1629 named_vars = {
1632 'id': issue_id,
1630 'id': issue_id,
1633 'repo': repo_name,
1631 'repo': repo_name,
1634 'repo_name': repo_name_cleaned,
1632 'repo_name': repo_name_cleaned,
1635 'group_name': parent_group_name
1633 'group_name': parent_group_name
1636 }
1634 }
1637 # named regex variables
1635 # named regex variables
1638 named_vars.update(match_obj.groupdict())
1636 named_vars.update(match_obj.groupdict())
1639 _url = string.Template(entry['url']).safe_substitute(**named_vars)
1637 _url = string.Template(entry['url']).safe_substitute(**named_vars)
1640
1638
1641 return tmpl % {
1639 return tmpl % {
1642 'pref': pref,
1640 'pref': pref,
1643 'cls': 'issue-tracker-link',
1641 'cls': 'issue-tracker-link',
1644 'url': _url,
1642 'url': _url,
1645 'id-repr': issue_id,
1643 'id-repr': issue_id,
1646 'issue-prefix': entry['pref'],
1644 'issue-prefix': entry['pref'],
1647 'serv': entry['url'],
1645 'serv': entry['url'],
1648 }
1646 }
1649
1647
1650
1648
1651 def process_patterns(text_string, repo_name, config):
1649 def process_patterns(text_string, repo_name, config):
1652 repo = None
1650 repo = None
1653 if repo_name:
1651 if repo_name:
1654 # Retrieving repo_name to avoid invalid repo_name to explode on
1652 # Retrieving repo_name to avoid invalid repo_name to explode on
1655 # IssueTrackerSettingsModel but still passing invalid name further down
1653 # IssueTrackerSettingsModel but still passing invalid name further down
1656 repo = Repository.get_by_repo_name(repo_name, cache=True)
1654 repo = Repository.get_by_repo_name(repo_name, cache=True)
1657
1655
1658 settings_model = IssueTrackerSettingsModel(repo=repo)
1656 settings_model = IssueTrackerSettingsModel(repo=repo)
1659 active_entries = settings_model.get_settings(cache=True)
1657 active_entries = settings_model.get_settings(cache=True)
1660
1658
1661 newtext = text_string
1659 newtext = text_string
1662 for uid, entry in active_entries.items():
1660 for uid, entry in active_entries.items():
1663 url_func = partial(
1661 url_func = partial(
1664 _process_url_func, repo_name=repo_name, entry=entry, uid=uid)
1662 _process_url_func, repo_name=repo_name, entry=entry, uid=uid)
1665
1663
1666 log.debug('found issue tracker entry with uid %s' % (uid,))
1664 log.debug('found issue tracker entry with uid %s' % (uid,))
1667
1665
1668 if not (entry['pat'] and entry['url']):
1666 if not (entry['pat'] and entry['url']):
1669 log.debug('skipping due to missing data')
1667 log.debug('skipping due to missing data')
1670 continue
1668 continue
1671
1669
1672 log.debug('issue tracker entry: uid: `%s` PAT:%s URL:%s PREFIX:%s'
1670 log.debug('issue tracker entry: uid: `%s` PAT:%s URL:%s PREFIX:%s'
1673 % (uid, entry['pat'], entry['url'], entry['pref']))
1671 % (uid, entry['pat'], entry['url'], entry['pref']))
1674
1672
1675 try:
1673 try:
1676 pattern = re.compile(r'%s' % entry['pat'])
1674 pattern = re.compile(r'%s' % entry['pat'])
1677 except re.error:
1675 except re.error:
1678 log.exception(
1676 log.exception(
1679 'issue tracker pattern: `%s` failed to compile',
1677 'issue tracker pattern: `%s` failed to compile',
1680 entry['pat'])
1678 entry['pat'])
1681 continue
1679 continue
1682
1680
1683 newtext = pattern.sub(url_func, newtext)
1681 newtext = pattern.sub(url_func, newtext)
1684 log.debug('processed prefix:uid `%s`' % (uid,))
1682 log.debug('processed prefix:uid `%s`' % (uid,))
1685
1683
1686 return newtext
1684 return newtext
1687
1685
1688
1686
1689 def urlify_commit_message(commit_text, repository=None):
1687 def urlify_commit_message(commit_text, repository=None):
1690 """
1688 """
1691 Parses given text message and makes proper links.
1689 Parses given text message and makes proper links.
1692 issues are linked to given issue-server, and rest is a commit link
1690 issues are linked to given issue-server, and rest is a commit link
1693
1691
1694 :param commit_text:
1692 :param commit_text:
1695 :param repository:
1693 :param repository:
1696 """
1694 """
1697 from pylons import url # doh, we need to re-import url to mock it later
1695 from pylons import url # doh, we need to re-import url to mock it later
1698 from rhodecode import CONFIG
1696 from rhodecode import CONFIG
1699
1697
1700 def escaper(string):
1698 def escaper(string):
1701 return string.replace('<', '&lt;').replace('>', '&gt;')
1699 return string.replace('<', '&lt;').replace('>', '&gt;')
1702
1700
1703 newtext = escaper(commit_text)
1701 newtext = escaper(commit_text)
1704 # urlify commits - extract commit ids and make link out of them, if we have
1702 # urlify commits - extract commit ids and make link out of them, if we have
1705 # the scope of repository present.
1703 # the scope of repository present.
1706 if repository:
1704 if repository:
1707 newtext = urlify_commits(newtext, repository)
1705 newtext = urlify_commits(newtext, repository)
1708
1706
1709 # extract http/https links and make them real urls
1707 # extract http/https links and make them real urls
1710 newtext = urlify_text(newtext, safe=False)
1708 newtext = urlify_text(newtext, safe=False)
1711
1709
1712 # process issue tracker patterns
1710 # process issue tracker patterns
1713 newtext = process_patterns(newtext, repository or '', CONFIG)
1711 newtext = process_patterns(newtext, repository or '', CONFIG)
1714
1712
1715 return literal(newtext)
1713 return literal(newtext)
1716
1714
1717
1715
1718 def rst(source, mentions=False):
1716 def rst(source, mentions=False):
1719 return literal('<div class="rst-block">%s</div>' %
1717 return literal('<div class="rst-block">%s</div>' %
1720 MarkupRenderer.rst(source, mentions=mentions))
1718 MarkupRenderer.rst(source, mentions=mentions))
1721
1719
1722
1720
1723 def markdown(source, mentions=False):
1721 def markdown(source, mentions=False):
1724 return literal('<div class="markdown-block">%s</div>' %
1722 return literal('<div class="markdown-block">%s</div>' %
1725 MarkupRenderer.markdown(source, flavored=True,
1723 MarkupRenderer.markdown(source, flavored=True,
1726 mentions=mentions))
1724 mentions=mentions))
1727
1725
1728 def renderer_from_filename(filename, exclude=None):
1726 def renderer_from_filename(filename, exclude=None):
1729 return MarkupRenderer.renderer_from_filename(filename, exclude=exclude)
1727 return MarkupRenderer.renderer_from_filename(filename, exclude=exclude)
1730
1728
1731
1729
1732 def render(source, renderer='rst', mentions=False):
1730 def render(source, renderer='rst', mentions=False):
1733 if renderer == 'rst':
1731 if renderer == 'rst':
1734 return rst(source, mentions=mentions)
1732 return rst(source, mentions=mentions)
1735 if renderer == 'markdown':
1733 if renderer == 'markdown':
1736 return markdown(source, mentions=mentions)
1734 return markdown(source, mentions=mentions)
1737
1735
1738
1736
1739 def commit_status(repo, commit_id):
1737 def commit_status(repo, commit_id):
1740 return ChangesetStatusModel().get_status(repo, commit_id)
1738 return ChangesetStatusModel().get_status(repo, commit_id)
1741
1739
1742
1740
1743 def commit_status_lbl(commit_status):
1741 def commit_status_lbl(commit_status):
1744 return dict(ChangesetStatus.STATUSES).get(commit_status)
1742 return dict(ChangesetStatus.STATUSES).get(commit_status)
1745
1743
1746
1744
1747 def commit_time(repo_name, commit_id):
1745 def commit_time(repo_name, commit_id):
1748 repo = Repository.get_by_repo_name(repo_name)
1746 repo = Repository.get_by_repo_name(repo_name)
1749 commit = repo.get_commit(commit_id=commit_id)
1747 commit = repo.get_commit(commit_id=commit_id)
1750 return commit.date
1748 return commit.date
1751
1749
1752
1750
1753 def get_permission_name(key):
1751 def get_permission_name(key):
1754 return dict(Permission.PERMS).get(key)
1752 return dict(Permission.PERMS).get(key)
1755
1753
1756
1754
1757 def journal_filter_help():
1755 def journal_filter_help():
1758 return _(
1756 return _(
1759 'Example filter terms:\n' +
1757 'Example filter terms:\n' +
1760 ' repository:vcs\n' +
1758 ' repository:vcs\n' +
1761 ' username:marcin\n' +
1759 ' username:marcin\n' +
1762 ' action:*push*\n' +
1760 ' action:*push*\n' +
1763 ' ip:127.0.0.1\n' +
1761 ' ip:127.0.0.1\n' +
1764 ' date:20120101\n' +
1762 ' date:20120101\n' +
1765 ' date:[20120101100000 TO 20120102]\n' +
1763 ' date:[20120101100000 TO 20120102]\n' +
1766 '\n' +
1764 '\n' +
1767 'Generate wildcards using \'*\' character:\n' +
1765 'Generate wildcards using \'*\' character:\n' +
1768 ' "repository:vcs*" - search everything starting with \'vcs\'\n' +
1766 ' "repository:vcs*" - search everything starting with \'vcs\'\n' +
1769 ' "repository:*vcs*" - search for repository containing \'vcs\'\n' +
1767 ' "repository:*vcs*" - search for repository containing \'vcs\'\n' +
1770 '\n' +
1768 '\n' +
1771 'Optional AND / OR operators in queries\n' +
1769 'Optional AND / OR operators in queries\n' +
1772 ' "repository:vcs OR repository:test"\n' +
1770 ' "repository:vcs OR repository:test"\n' +
1773 ' "username:test AND repository:test*"\n'
1771 ' "username:test AND repository:test*"\n'
1774 )
1772 )
1775
1773
1776
1774
1777 def not_mapped_error(repo_name):
1775 def not_mapped_error(repo_name):
1778 flash(_('%s repository is not mapped to db perhaps'
1776 flash(_('%s repository is not mapped to db perhaps'
1779 ' it was created or renamed from the filesystem'
1777 ' it was created or renamed from the filesystem'
1780 ' please run the application again'
1778 ' please run the application again'
1781 ' in order to rescan repositories') % repo_name, category='error')
1779 ' in order to rescan repositories') % repo_name, category='error')
1782
1780
1783
1781
1784 def ip_range(ip_addr):
1782 def ip_range(ip_addr):
1785 from rhodecode.model.db import UserIpMap
1783 from rhodecode.model.db import UserIpMap
1786 s, e = UserIpMap._get_ip_range(ip_addr)
1784 s, e = UserIpMap._get_ip_range(ip_addr)
1787 return '%s - %s' % (s, e)
1785 return '%s - %s' % (s, e)
1788
1786
1789
1787
1790 def form(url, method='post', needs_csrf_token=True, **attrs):
1788 def form(url, method='post', needs_csrf_token=True, **attrs):
1791 """Wrapper around webhelpers.tags.form to prevent CSRF attacks."""
1789 """Wrapper around webhelpers.tags.form to prevent CSRF attacks."""
1792 if method.lower() != 'get' and needs_csrf_token:
1790 if method.lower() != 'get' and needs_csrf_token:
1793 raise Exception(
1791 raise Exception(
1794 'Forms to POST/PUT/DELETE endpoints should have (in general) a ' +
1792 'Forms to POST/PUT/DELETE endpoints should have (in general) a ' +
1795 'CSRF token. If the endpoint does not require such token you can ' +
1793 'CSRF token. If the endpoint does not require such token you can ' +
1796 'explicitly set the parameter needs_csrf_token to false.')
1794 'explicitly set the parameter needs_csrf_token to false.')
1797
1795
1798 return wh_form(url, method=method, **attrs)
1796 return wh_form(url, method=method, **attrs)
1799
1797
1800
1798
1801 def secure_form(url, method="POST", multipart=False, **attrs):
1799 def secure_form(url, method="POST", multipart=False, **attrs):
1802 """Start a form tag that points the action to an url. This
1800 """Start a form tag that points the action to an url. This
1803 form tag will also include the hidden field containing
1801 form tag will also include the hidden field containing
1804 the auth token.
1802 the auth token.
1805
1803
1806 The url options should be given either as a string, or as a
1804 The url options should be given either as a string, or as a
1807 ``url()`` function. The method for the form defaults to POST.
1805 ``url()`` function. The method for the form defaults to POST.
1808
1806
1809 Options:
1807 Options:
1810
1808
1811 ``multipart``
1809 ``multipart``
1812 If set to True, the enctype is set to "multipart/form-data".
1810 If set to True, the enctype is set to "multipart/form-data".
1813 ``method``
1811 ``method``
1814 The method to use when submitting the form, usually either
1812 The method to use when submitting the form, usually either
1815 "GET" or "POST". If "PUT", "DELETE", or another verb is used, a
1813 "GET" or "POST". If "PUT", "DELETE", or another verb is used, a
1816 hidden input with name _method is added to simulate the verb
1814 hidden input with name _method is added to simulate the verb
1817 over POST.
1815 over POST.
1818
1816
1819 """
1817 """
1820 from webhelpers.pylonslib.secure_form import insecure_form
1818 from webhelpers.pylonslib.secure_form import insecure_form
1821 from rhodecode.lib.auth import get_csrf_token, csrf_token_key
1819 from rhodecode.lib.auth import get_csrf_token, csrf_token_key
1822 form = insecure_form(url, method, multipart, **attrs)
1820 form = insecure_form(url, method, multipart, **attrs)
1823 token = HTML.div(hidden(csrf_token_key, get_csrf_token()), style="display: none;")
1821 token = HTML.div(hidden(csrf_token_key, get_csrf_token()), style="display: none;")
1824 return literal("%s\n%s" % (form, token))
1822 return literal("%s\n%s" % (form, token))
1825
1823
1826 def dropdownmenu(name, selected, options, enable_filter=False, **attrs):
1824 def dropdownmenu(name, selected, options, enable_filter=False, **attrs):
1827 select_html = select(name, selected, options, **attrs)
1825 select_html = select(name, selected, options, **attrs)
1828 select2 = """
1826 select2 = """
1829 <script>
1827 <script>
1830 $(document).ready(function() {
1828 $(document).ready(function() {
1831 $('#%s').select2({
1829 $('#%s').select2({
1832 containerCssClass: 'drop-menu',
1830 containerCssClass: 'drop-menu',
1833 dropdownCssClass: 'drop-menu-dropdown',
1831 dropdownCssClass: 'drop-menu-dropdown',
1834 dropdownAutoWidth: true%s
1832 dropdownAutoWidth: true%s
1835 });
1833 });
1836 });
1834 });
1837 </script>
1835 </script>
1838 """
1836 """
1839 filter_option = """,
1837 filter_option = """,
1840 minimumResultsForSearch: -1
1838 minimumResultsForSearch: -1
1841 """
1839 """
1842 input_id = attrs.get('id') or name
1840 input_id = attrs.get('id') or name
1843 filter_enabled = "" if enable_filter else filter_option
1841 filter_enabled = "" if enable_filter else filter_option
1844 select_script = literal(select2 % (input_id, filter_enabled))
1842 select_script = literal(select2 % (input_id, filter_enabled))
1845
1843
1846 return literal(select_html+select_script)
1844 return literal(select_html+select_script)
1847
1845
1848
1846
1849 def get_visual_attr(tmpl_context_var, attr_name):
1847 def get_visual_attr(tmpl_context_var, attr_name):
1850 """
1848 """
1851 A safe way to get a variable from visual variable of template context
1849 A safe way to get a variable from visual variable of template context
1852
1850
1853 :param tmpl_context_var: instance of tmpl_context, usually present as `c`
1851 :param tmpl_context_var: instance of tmpl_context, usually present as `c`
1854 :param attr_name: name of the attribute we fetch from the c.visual
1852 :param attr_name: name of the attribute we fetch from the c.visual
1855 """
1853 """
1856 visual = getattr(tmpl_context_var, 'visual', None)
1854 visual = getattr(tmpl_context_var, 'visual', None)
1857 if not visual:
1855 if not visual:
1858 return
1856 return
1859 else:
1857 else:
1860 return getattr(visual, attr_name, None)
1858 return getattr(visual, attr_name, None)
1861
1859
1862
1860
1863 def get_last_path_part(file_node):
1861 def get_last_path_part(file_node):
1864 if not file_node.path:
1862 if not file_node.path:
1865 return u''
1863 return u''
1866
1864
1867 path = safe_unicode(file_node.path.split('/')[-1])
1865 path = safe_unicode(file_node.path.split('/')[-1])
1868 return u'../' + path
1866 return u'../' + path
1869
1867
1870
1868
1871 def route_path(*args, **kwds):
1869 def route_path(*args, **kwds):
1872 """
1870 """
1873 Wrapper around pyramids `route_path` function. It is used to generate
1871 Wrapper around pyramids `route_path` function. It is used to generate
1874 URLs from within pylons views or templates. This will be removed when
1872 URLs from within pylons views or templates. This will be removed when
1875 pyramid migration if finished.
1873 pyramid migration if finished.
1876 """
1874 """
1877 req = get_current_request()
1875 req = get_current_request()
1878 return req.route_path(*args, **kwds)
1876 return req.route_path(*args, **kwds)
1879
1877
1880
1878
1881 def resource_path(*args, **kwds):
1879 def resource_path(*args, **kwds):
1882 """
1880 """
1883 Wrapper around pyramids `route_path` function. It is used to generate
1881 Wrapper around pyramids `route_path` function. It is used to generate
1884 URLs from within pylons views or templates. This will be removed when
1882 URLs from within pylons views or templates. This will be removed when
1885 pyramid migration if finished.
1883 pyramid migration if finished.
1886 """
1884 """
1887 req = get_current_request()
1885 req = get_current_request()
1888 return req.resource_path(*args, **kwds)
1886 return req.resource_path(*args, **kwds)
General Comments 0
You need to be logged in to leave comments. Login now