# -*- coding: utf-8 -*-
"""
rhodecode.controllers.files
~~~~~~~~~~~~~~~~~~~~~~~~~~~
Files controller for RhodeCode
:created_on: Apr 21, 2010
:author: marcink
:copyright: (C) 2009-2011 Marcin Kuzminski <marcin@python-works.com>
:license: GPLv3, see COPYING for more details.
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import os
import logging
import mimetypes
import traceback
from pylons import request, response, session, tmpl_context as c, url
from pylons.i18n.translation import _
from pylons.controllers.util import redirect
from vcs.backends import ARCHIVE_SPECS
from vcs.exceptions import RepositoryError, ChangesetDoesNotExistError, \
EmptyRepositoryError, ImproperArchiveTypeError, VCSError
from vcs.nodes import FileNode, NodeKind
from vcs.utils import diffs as differ
from rhodecode.lib import convert_line_endings, detect_mode, safe_str
from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator
from rhodecode.lib.base import BaseRepoController, render
from rhodecode.lib.utils import EmptyChangeset
import rhodecode.lib.helpers as h
from rhodecode.model.repo import RepoModel
log = logging.getLogger(__name__)
class FilesController(BaseRepoController):
@LoginRequired()
def __before__(self):
super(FilesController, self).__before__()
c.cut_off_limit = self.cut_off_limit
def __get_cs_or_redirect(self, rev, repo_name):
Safe way to get changeset if error occur it redirects to tip with
proper message
:param rev: revision to fetch
:param repo_name: repo name to redirect after
try:
return c.rhodecode_repo.get_changeset(rev)
except EmptyRepositoryError, e:
h.flash(_('There are no files yet'), category='warning')
redirect(h.url('summary_home', repo_name=repo_name))
except RepositoryError, e:
h.flash(str(e), category='warning')
redirect(h.url('files_home', repo_name=repo_name, revision='tip'))
def __get_filenode_or_redirect(self, repo_name, cs, path):
Returns file_node, if error occurs or given path is directory,
it'll redirect to top level path
:param repo_name: repo_name
:param cs: given changeset
:param path: path to lookup
file_node = cs.get_node(path)
if file_node.is_dir():
raise RepositoryError('given path is a directory')
redirect(h.url('files_home', repo_name=repo_name,
revision=cs.raw_id))
return file_node
@HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
'repository.admin')
def index(self, repo_name, revision, f_path):
#reditect to given revision from form if given
post_revision = request.POST.get('at_rev', None)
if post_revision:
cs = self.__get_cs_or_redirect(post_revision, repo_name)
redirect(url('files_home', repo_name=c.repo_name,
revision=cs.raw_id, f_path=f_path))
c.changeset = self.__get_cs_or_redirect(revision, repo_name)
c.branch = request.GET.get('branch', None)
c.f_path = f_path
cur_rev = c.changeset.revision
#prev link
prev_rev = c.rhodecode_repo.get_changeset(cur_rev).prev(c.branch)
c.url_prev = url('files_home', repo_name=c.repo_name,
revision=prev_rev.raw_id, f_path=f_path)
if c.branch:
c.url_prev += '?branch=%s' % c.branch
except (ChangesetDoesNotExistError, VCSError):
c.url_prev = '#'
#next link
next_rev = c.rhodecode_repo.get_changeset(cur_rev).next(c.branch)
c.url_next = url('files_home', repo_name=c.repo_name,
revision=next_rev.raw_id, f_path=f_path)
c.url_next += '?branch=%s' % c.branch
c.url_next = '#'
#files or dirs
c.files_list = c.changeset.get_node(f_path)
if c.files_list.is_file():
c.file_history = self._get_node_history(c.changeset, f_path)
else:
c.file_history = []
revision=revision))
return render('files/files.html')
def rawfile(self, repo_name, revision, f_path):
cs = self.__get_cs_or_redirect(revision, repo_name)
file_node = self.__get_filenode_or_redirect(repo_name, cs, f_path)
response.content_disposition = 'attachment; filename=%s' % \
safe_str(f_path.split(os.sep)[-1])
response.content_type = file_node.mimetype
return file_node.content
def raw(self, repo_name, revision, f_path):
raw_mimetype_mapping = {
# map original mimetype to a mimetype used for "show as raw"
# you can also provide a content-disposition to override the
# default "attachment" disposition.
# orig_type: (new_type, new_dispo)
# show images inline:
'image/x-icon': ('image/x-icon', 'inline'),
'image/png': ('image/png', 'inline'),
'image/gif': ('image/gif', 'inline'),
'image/jpeg': ('image/jpeg', 'inline'),
'image/svg+xml': ('image/svg+xml', 'inline'),
}
mimetype = file_node.mimetype
mimetype, dispo = raw_mimetype_mapping[mimetype]
except KeyError:
# we don't know anything special about this, handle it safely
if file_node.is_binary:
# do same as download raw for binary files
mimetype, dispo = 'application/octet-stream', 'attachment'
# do not just use the original mimetype, but force text/plain,
# otherwise it would serve text/html and that might be unsafe.
# Note: underlying vcs library fakes text/plain mimetype if the
# mimetype can not be determined and it thinks it is not
# binary.This might lead to erroneous text display in some
# cases, but helps in other cases, like with text files
# without extension.
mimetype, dispo = 'text/plain', 'inline'
if dispo == 'attachment':
dispo = 'attachment; filename=%s' % \
response.content_disposition = dispo
response.content_type = mimetype
def annotate(self, repo_name, revision, f_path):
c.cs = self.__get_cs_or_redirect(revision, repo_name)
c.file = self.__get_filenode_or_redirect(repo_name, c.cs, f_path)
c.file_history = self._get_node_history(c.cs, f_path)
return render('files/files_annotate.html')
@HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')
def edit(self, repo_name, revision, f_path):
r_post = request.POST
if c.file.is_binary:
return redirect(url('files_home', repo_name=c.repo_name,
revision=c.cs.raw_id, f_path=f_path))
if r_post:
old_content = c.file.content
sl = old_content.splitlines(1)
first_line = sl[0] if sl else ''
# modes: 0 - Unix, 1 - Mac, 2 - DOS
mode = detect_mode(first_line, 0)
content = convert_line_endings(r_post.get('content'), mode)
message = r_post.get('message') or (_('Edited %s via RhodeCode')
% (f_path))
author = self.rhodecode_user.full_contact
if content == old_content:
h.flash(_('No changes'),
category='warning')
return redirect(url('changeset_home', repo_name=c.repo_name,
revision='tip'))
self.scm_model.commit_change(repo=c.rhodecode_repo,
repo_name=repo_name, cs=c.cs,
user=self.rhodecode_user,
author=author, message=message,
content=content, f_path=f_path)
h.flash(_('Successfully committed to %s' % f_path),
category='success')
except Exception:
log.error(traceback.format_exc())
h.flash(_('Error occurred during commit'), category='error')
return redirect(url('changeset_home',
repo_name=c.repo_name, revision='tip'))
return render('files/files_edit.html')
def archivefile(self, repo_name, fname):
fileformat = None
revision = None
ext = None
subrepos = request.GET.get('subrepos') == 'true'
for a_type, ext_data in ARCHIVE_SPECS.items():
archive_spec = fname.split(ext_data[1])
if len(archive_spec) == 2 and archive_spec[1] == '':
fileformat = a_type or ext_data[1]
revision = archive_spec[0]
ext = ext_data[1]
dbrepo = RepoModel().get_by_repo_name(repo_name)
if dbrepo.enable_downloads is False:
return _('downloads disabled')
cs = c.rhodecode_repo.get_changeset(revision)
content_type = ARCHIVE_SPECS[fileformat][0]
except ChangesetDoesNotExistError:
return _('Unknown revision %s') % revision
except EmptyRepositoryError:
return _('Empty repository')
except (ImproperArchiveTypeError, KeyError):
return _('Unknown archive type')
response.content_type = content_type
response.content_disposition = 'attachment; filename=%s-%s%s' \
% (repo_name, revision, ext)
import tempfile
archive = tempfile.mkstemp()[1]
t = open(archive, 'wb')
cs.fill_archive(stream=t, kind=fileformat)
cs.fill_archive(stream=t, kind=fileformat, subrepos=subrepos)
def get_chunked_archive(archive):
stream = open(archive, 'rb')
while True:
data = stream.read(4096)
if not data:
os.remove(archive)
break
yield data
return get_chunked_archive(archive)
def diff(self, repo_name, f_path):
diff1 = request.GET.get('diff1')
diff2 = request.GET.get('diff2')
c.action = request.GET.get('diff')
c.no_changes = diff1 == diff2
c.big_diff = False
if diff1 not in ['', None, 'None', '0' * 12, '0' * 40]:
c.changeset_1 = c.rhodecode_repo.get_changeset(diff1)
node1 = c.changeset_1.get_node(f_path)
c.changeset_1 = EmptyChangeset(repo=c.rhodecode_repo)
node1 = FileNode('.', '', changeset=c.changeset_1)
if diff2 not in ['', None, 'None', '0' * 12, '0' * 40]:
c.changeset_2 = c.rhodecode_repo.get_changeset(diff2)
node2 = c.changeset_2.get_node(f_path)
c.changeset_2 = EmptyChangeset(repo=c.rhodecode_repo)
node2 = FileNode('.', '', changeset=c.changeset_2)
except RepositoryError:
return redirect(url('files_home',
repo_name=c.repo_name, f_path=f_path))
if c.action == 'download':
diff = differ.DiffProcessor(differ.get_gitdiff(node1, node2),
format='gitdiff')
diff_name = '%s_vs_%s.diff' % (diff1, diff2)
response.content_type = 'text/plain'
response.content_disposition = 'attachment; filename=%s' \
% diff_name
return diff.raw_diff()
elif c.action == 'raw':
elif c.action == 'diff':
if node1.is_binary or node2.is_binary:
c.cur_diff = _('Binary file')
elif node1.size > self.cut_off_limit or \
node2.size > self.cut_off_limit:
c.cur_diff = ''
c.big_diff = True
c.cur_diff = diff.as_html()
#default option
if not c.cur_diff and not c.big_diff:
c.no_changes = True
return render('files/file_diff.html')
def _get_node_history(self, cs, f_path):
changesets = cs.get_file_history(f_path)
hist_l = []
changesets_group = ([], _("Changesets"))
branches_group = ([], _("Branches"))
tags_group = ([], _("Tags"))
for chs in changesets:
n_desc = 'r%s:%s' % (chs.revision, chs.short_id)
changesets_group[0].append((chs.raw_id, n_desc,))
hist_l.append(changesets_group)
for name, chs in c.rhodecode_repo.branches.items():
#chs = chs.split(':')[-1]
branches_group[0].append((chs, name),)
hist_l.append(branches_group)
for name, chs in c.rhodecode_repo.tags.items():
tags_group[0].append((chs, name),)
hist_l.append(tags_group)
return hist_l
<%inherit file="/base/base.html"/>
<%def name="title()">
${c.repo_name} ${_('Summary')} - ${c.rhodecode_name}
</%def>
<%def name="breadcrumbs_links()">
${h.link_to(u'Home',h.url('/'))}
»
${h.link_to(c.dbrepo.just_name,h.url('summary_home',repo_name=c.repo_name))}
${_('summary')}
<%def name="page_nav()">
${self.menu('summary')}
<%def name="main()">
<div class="box box-left">
<!-- box / title -->
<div class="title">
${self.breadcrumbs()}
</div>
<!-- end box / title -->
<div class="form">
<div id="summary" class="fields">
<div class="field">
<div class="label">
<label>${_('Name')}:</label>
<div class="input-short">
%if c.rhodecode_user.username != 'default':
%if c.following:
<span id="follow_toggle" class="following" title="${_('Stop following this repository')}"
onclick="javascript:toggleFollowingRepo(this,${c.dbrepo.repo_id},'${str(h.get_token())}')">
</span>
%else:
<span id="follow_toggle" class="follow" title="${_('Start following this repository')}"
%endif
%endif:
##REPO TYPE
%if c.dbrepo.repo_type =='hg':
<img style="margin-bottom:2px" class="icon" title="${_('Mercurial repository')}" alt="${_('Mercurial repository')}" src="${h.url("/images/icons/hgicon.png")}"/>
%if c.dbrepo.repo_type =='git':
<img style="margin-bottom:2px" class="icon" title="${_('Git repository')}" alt="${_('Git repository')}" src="${h.url("/images/icons/giticon.png")}"/>
##PUBLIC/PRIVATE
%if c.dbrepo.private:
<img style="margin-bottom:2px" class="icon" title="${_('private repository')}" alt="${_('private repository')}" src="${h.url("/images/icons/lock.png")}"/>
<img style="margin-bottom:2px" class="icon" title="${_('public repository')}" alt="${_('public repository')}" src="${h.url("/images/icons/lock_open.png")}"/>
##REPO NAME
<span class="repo_name">${h.repo_link(c.dbrepo.groups_and_repo)}</span>
##FORK
%if c.dbrepo.fork:
<div style="margin-top:5px;clear:both"">
<a href="${h.url('summary_home',repo_name=c.dbrepo.fork.repo_name)}">
<img class="icon" alt="${_('public')}"
title="${_('Fork of')} ${c.dbrepo.fork.repo_name}"
src="${h.url("/images/icons/arrow_divide.png")}"/>
${_('Fork of')} ${c.dbrepo.fork.repo_name}
</a>
##REMOTE
%if c.dbrepo.clone_uri:
<div style="margin-top:5px;clear:both">
<a href="${h.url(str(h.hide_credentials(c.dbrepo.clone_uri)))}">
<img class="icon" alt="${_('remote clone')}"
title="${_('Clone from')} ${h.hide_credentials(c.dbrepo.clone_uri)}"
src="${h.url("/images/icons/connect.png")}"/>
${_('Clone from')} ${h.hide_credentials(c.dbrepo.clone_uri)}
<label>${_('Description')}:</label>
<div class="input-short desc">${h.urlify_text(c.dbrepo.description)}</div>
<label>${_('Contact')}:</label>
<div class="gravatar">
<img alt="gravatar" src="${h.gravatar_url(c.dbrepo.user.email)}"/>
${_('Username')}: ${c.dbrepo.user.username}<br/>
${_('Name')}: ${c.dbrepo.user.name} ${c.dbrepo.user.lastname}<br/>
${_('Email')}: <a href="mailto:${c.dbrepo.user.email}">${c.dbrepo.user.email}</a>
<label>${_('Last change')}:</label>
<b>${'r%s:%s' % (h.get_changeset_safe(c.rhodecode_repo,'tip').revision,
h.get_changeset_safe(c.rhodecode_repo,'tip').short_id)}</b> -
<span class="tooltip" title="${c.rhodecode_repo.last_change}">
${h.age(c.rhodecode_repo.last_change)}</span><br/>
${_('by')} ${h.get_changeset_safe(c.rhodecode_repo,'tip').author}
<label>${_('Clone url')}:</label>
<input type="text" id="clone_url" readonly="readonly" value="${c.rhodecode_repo.alias} clone ${c.clone_repo_url}" size="70"/>
<label>${_('Trending source files')}:</label>
<div id="lang_stats"></div>
<label>${_('Download')}:</label>
%if len(c.rhodecode_repo.revisions) == 0:
${_('There are no downloads yet')}
%elif c.enable_downloads is False:
${_('Downloads are disabled for this repository')}
%if h.HasPermissionAll('hg.admin')('enable stats on from summary'):
[${h.link_to(_('enable'),h.url('edit_repo',repo_name=c.repo_name))}]
${h.select('download_options',c.rhodecode_repo.get_changeset().raw_id,c.download_options)}
%for cnt,archive in enumerate(c.rhodecode_repo._get_archives()):
%if cnt >=1:
|
<span class="tooltip" title="${_('Download %s as %s') %('tip',archive['type'])}"
id="${archive['type']+'_link'}">${h.link_to(archive['type'],
h.url('files_archive_home',repo_name=c.dbrepo.repo_name,
fname='tip'+archive['extension']),class_="archive_icon")}</span>
%endfor
<span style="vertical-align: bottom">
<input id="archive_subrepos" type="checkbox" name="subrepos"/> <span class="tooltip" title="${_('Check this to download archive with subrepos')}" >${_('with subrepos')}</span>
<label>${_('Feeds')}:</label>
${h.link_to(_('RSS'),h.url('rss_feed_home',repo_name=c.dbrepo.repo_name,api_key=c.rhodecode_user.api_key),class_='rss_icon')}
${h.link_to(_('Atom'),h.url('atom_feed_home',repo_name=c.dbrepo.repo_name,api_key=c.rhodecode_user.api_key),class_='atom_icon')}
${h.link_to(_('RSS'),h.url('rss_feed_home',repo_name=c.dbrepo.repo_name),class_='rss_icon')}
${h.link_to(_('Atom'),h.url('atom_feed_home',repo_name=c.dbrepo.repo_name),class_='atom_icon')}
<script type="text/javascript">
YUE.onDOMReady(function(e){
id = 'clone_url';
YUE.on(id,'click',function(e){
if(YUD.hasClass(id,'selected')){
return
else{
YUD.addClass(id,'selected');
YUD.get(id).select();
})
var data = ${c.trending_languages|n};
var total = 0;
var no_data = true;
for (k in data){
total += data[k].count;
no_data = false;
var tbl = document.createElement('table');
tbl.setAttribute('class','trending_language_tbl');
var cnt = 0;
cnt += 1;
var hide = cnt>2;
var tr = document.createElement('tr');
if (hide){
tr.setAttribute('style','display:none');
tr.setAttribute('class','stats_hidden');
var percentage = Math.round((data[k].count/total*100),2);
var value = data[k].count;
var td1 = document.createElement('td');
td1.width = 150;
var trending_language_label = document.createElement('div');
trending_language_label.innerHTML = data[k].desc+" ("+k+")";
td1.appendChild(trending_language_label);
var td2 = document.createElement('td');
td2.setAttribute('style','padding-right:14px !important');
var trending_language = document.createElement('div');
var nr_files = value+" ${_('files')}";
trending_language.title = k+" "+nr_files;
if (percentage>22){
trending_language.innerHTML = "<b style='font-size:0.8em'>"+percentage+"% "+nr_files+ "</b>";
trending_language.innerHTML = "<b style='font-size:0.8em'>"+percentage+"%</b>";
trending_language.setAttribute("class", 'trending_language top-right-rounded-corner bottom-right-rounded-corner');
trending_language.style.width=percentage+"%";
td2.appendChild(trending_language);
tr.appendChild(td1);
tr.appendChild(td2);
tbl.appendChild(tr);
if(cnt == 3){
var show_more = document.createElement('tr');
var td = document.createElement('td');
lnk = document.createElement('a');
lnk.href='#';
lnk.innerHTML = "${_('show more')}";
lnk.id='code_stats_show_more';
td.appendChild(lnk);
show_more.appendChild(td);
show_more.appendChild(document.createElement('td'));
tbl.appendChild(show_more);
if(no_data){
td1.innerHTML = "${c.no_data_msg}";
YUD.get('lang_stats').appendChild(tbl);
YUE.on('code_stats_show_more','click',function(){
l = YUD.getElementsByClassName('stats_hidden')
for (e in l){
YUD.setStyle(l[e],'display','');
};
YUD.setStyle(YUD.get('code_stats_show_more'),
'display','none');
YUE.on('download_options','change',function(e){
var new_cs = e.target.options[e.target.selectedIndex];
var tmpl_links = {}
tmpl_links['${archive['type']}'] = '${h.link_to(archive['type'],
fname='__CS__'+archive['extension']),class_="archive_icon")}';
fname='__CS__'+archive['extension'],subrepos='__SUB__'),class_="archive_icon")}';
YUE.on(['download_options','archive_subrepos'],'change',function(e){
var sm = YUD.get('download_options');
var new_cs = sm.options[sm.selectedIndex];
for(k in tmpl_links){
var s = YUD.get(k+'_link')
var s = YUD.get(k+'_link');
title_tmpl = "${_('Download %s as %s') % ('__CS_NAME__','__CS_EXT__')}";
s.title = title_tmpl.replace('__CS_NAME__',new_cs.text);
s.title = s.title.replace('__CS_EXT__',k);
s.innerHTML = tmpl_links[k].replace('__CS__',new_cs.value);
var url = tmpl_links[k].replace('__CS__',new_cs.value);
var subrepos = YUD.get('archive_subrepos').checked
url = url.replace('__SUB__',subrepos);
s.innerHTML = url
});
</script>
<div class="box box-right" style="min-height:455px">
<h5>${_('Commit activity by day / author')}</h5>
<div class="graph">
<div style="padding:0 10px 10px 15px;font-size: 1.2em;">
%if c.no_data:
${c.no_data_msg}
${_('Loaded in')} ${c.stats_percentage} %
<div id="commit_history" style="width:450px;height:300px;float:left"></div>
<div style="clear: both;height: 10px"></div>
<div id="overview" style="width:450px;height:100px;float:left"></div>
<div id="legend_data" style="clear:both;margin-top:10px;">
<div id="legend_container"></div>
<div id="legend_choices">
<table id="legend_choices_tables" style="font-size:smaller;color:#545454"></table>
/**
* Plots summary graph
*
* @class SummaryPlot
* @param {from} initial from for detailed graph
* @param {to} initial to for detailed graph
* @param {dataset}
* @param {overview_dataset}
*/
function SummaryPlot(from,to,dataset,overview_dataset) {
var initial_ranges = {
"xaxis":{
"from":from,
"to":to,
},
var dataset = dataset;
var overview_dataset = [overview_dataset];
var choiceContainer = YUD.get("legend_choices");
var choiceContainerTable = YUD.get("legend_choices_tables");
var plotContainer = YUD.get('commit_history');
var overviewContainer = YUD.get('overview');
var plot_options = {
bars: {show:true,align:'center',lineWidth:4},
legend: {show:true, container:"legend_container"},
points: {show:true,radius:0,fill:false},
yaxis: {tickDecimals:0,},
xaxis: {
mode: "time",
timeformat: "%d/%m",
min:from,
max:to,
grid: {
hoverable: true,
clickable: true,
autoHighlight:true,
color: "#999"
//selection: {mode: "x"}
var overview_options = {
legend:{show:false},
bars: {show:true,barWidth: 2,},
shadowSize: 0,
xaxis: {mode: "time", timeformat: "%d/%m/%y",},
yaxis: {ticks: 3, min: 0,tickDecimals:0,},
grid: {color: "#999",},
selection: {mode: "x"}
*get dummy data needed in few places
function getDummyData(label){
return {"label":label,
"data":[{"time":0,
"commits":0,
"added":0,
"changed":0,
"removed":0,
}],
"schema":["commits"],
"color":'#ffffff',
* generate checkboxes accordindly to data
* @param keys
* @returns
function generateCheckboxes(data) {
//append checkboxes
var i = 0;
choiceContainerTable.innerHTML = '';
for(var pos in data) {
data[pos].color = i;
i++;
if(data[pos].label != ''){
choiceContainerTable.innerHTML += '<tr><td>'+
'<input type="checkbox" name="' + data[pos].label +'" checked="checked" />'
+data[pos].label+
'</td></tr>';
* ToolTip show
function showTooltip(x, y, contents) {
var div=document.getElementById('tooltip');
if(!div) {
div = document.createElement('div');
div.id="tooltip";
div.style.position="absolute";
div.style.border='1px solid #fdd';
div.style.padding='2px';
div.style.backgroundColor='#fee';
document.body.appendChild(div);
YUD.setStyle(div, 'opacity', 0);
div.innerHTML = contents;
div.style.top=(y + 5) + "px";
div.style.left=(x + 5) + "px";
var anim = new YAHOO.util.Anim(div, {opacity: {to: 0.8}}, 0.2);
anim.animate();
* This function will detect if selected period has some changesets
for this user if it does this data is then pushed for displaying
Additionally it will only display users that are selected by the checkbox
function getDataAccordingToRanges(ranges) {
var data = [];
var new_dataset = {};
var keys = [];
var max_commits = 0;
for(var key in dataset){
for(var ds in dataset[key].data){
commit_data = dataset[key].data[ds];
if (commit_data.time >= ranges.xaxis.from && commit_data.time <= ranges.xaxis.to){
if(new_dataset[key] === undefined){
new_dataset[key] = {data:[],schema:["commits"],label:key};
new_dataset[key].data.push(commit_data);
if (new_dataset[key] !== undefined){
data.push(new_dataset[key]);
if (data.length > 0){
return data;
//just return dummy data for graph to plot itself
return [getDummyData('')];
* redraw using new checkbox data
function plotchoiced(e,args){
var cur_data = args[0];
var cur_ranges = args[1];
var new_data = [];
var inputs = choiceContainer.getElementsByTagName("input");
//show only checked labels
for(var i=0; i<inputs.length; i++) {
var checkbox_key = inputs[i].name;
if(inputs[i].checked){
for(var d in cur_data){
if(cur_data[d].label == checkbox_key){
new_data.push(cur_data[d]);
//push dummy data to not hide the label
new_data.push(getDummyData(checkbox_key));
var new_options = YAHOO.lang.merge(plot_options, {
min: cur_ranges.xaxis.from,
max: cur_ranges.xaxis.to,
mode:"time",
if (!new_data){
new_data = [[0,1]];
// do the zooming
plot = YAHOO.widget.Flot(plotContainer, new_data, new_options);
plot.subscribe("plotselected", plotselected);
//resubscribe plothover
plot.subscribe("plothover", plothover);
// don't fire event on the overview to prevent eternal loop
overview.setSelection(cur_ranges, true);
* plot only selected items from overview
* @param ranges
function plotselected(ranges,cur_data) {
//updates the data for new plot
var data = getDataAccordingToRanges(ranges);
generateCheckboxes(data);
min: ranges.xaxis.from,
max: ranges.xaxis.to,
plot = YAHOO.widget.Flot(plotContainer, data, new_options);
overview.setSelection(ranges, true);
//resubscribe choiced
YUE.on(choiceContainer.getElementsByTagName("input"), "click", plotchoiced, [data, ranges]);
var previousPoint = null;
function plothover(o) {
var pos = o.pos;
var item = o.item;
//YUD.get("x").innerHTML = pos.x.toFixed(2);
//YUD.get("y").innerHTML = pos.y.toFixed(2);
if (item) {
if (previousPoint != item.datapoint) {
previousPoint = item.datapoint;
var tooltip = YUD.get("tooltip");
if(tooltip) {
tooltip.parentNode.removeChild(tooltip);
var x = item.datapoint.x.toFixed(2);
var y = item.datapoint.y.toFixed(2);
if (!item.series.label){
item.series.label = 'commits';
var d = new Date(x*1000);
var fd = d.toDateString()
var nr_commits = parseInt(y);
var cur_data = dataset[item.series.label].data[item.dataIndex];
var added = cur_data.added;
var changed = cur_data.changed;
var removed = cur_data.removed;
var nr_commits_suffix = " ${_('commits')} ";
var added_suffix = " ${_('files added')} ";
var changed_suffix = " ${_('files changed')} ";
var removed_suffix = " ${_('files removed')} ";
if(nr_commits == 1){nr_commits_suffix = " ${_('commit')} ";}
if(added==1){added_suffix=" ${_('file added')} ";}
if(changed==1){changed_suffix=" ${_('file changed')} ";}
if(removed==1){removed_suffix=" ${_('file removed')} ";}
showTooltip(item.pageX, item.pageY, item.series.label + " on " + fd
+'<br/>'+
nr_commits + nr_commits_suffix+'<br/>'+
added + added_suffix +'<br/>'+
changed + changed_suffix + '<br/>'+
removed + removed_suffix + '<br/>');
else {
previousPoint = null;
* MAIN EXECUTION
var data = getDataAccordingToRanges(initial_ranges);
//main plot
var plot = YAHOO.widget.Flot(plotContainer,data,plot_options);
//overview
var overview = YAHOO.widget.Flot(overviewContainer,
overview_dataset, overview_options);
//show initial selection on overview
overview.setSelection(initial_ranges);
plot.subscribe("plothover", plothover)
overview.subscribe("plotselected", function (ranges) {
plot.setSelection(ranges);
YUE.on(choiceContainer.getElementsByTagName("input"), "click", plotchoiced, [data, initial_ranges]);
SummaryPlot(${c.ts_min},${c.ts_max},${c.commit_data|n},${c.overview_data|n});
<div class="box">
<div class="breadcrumbs">${h.link_to(_('Shortlog'),h.url('shortlog_home',repo_name=c.repo_name))}</div>
<div class="table">
<div id="shortlog_data">
<%include file='../shortlog/shortlog_data.html'/>
##%if c.repo_changesets:
## ${h.link_to(_('show more'),h.url('changelog_home',repo_name=c.repo_name))}
##%endif
<div class="breadcrumbs">${h.link_to(_('Tags'),h.url('tags_home',repo_name=c.repo_name))}</div>
<%include file='../tags/tags_data.html'/>
%if c.repo_changesets:
${h.link_to(_('show more'),h.url('tags_home',repo_name=c.repo_name))}
Status change: