fixed issue #165 trending source files are now stored in cache as ext only, and translated to description only when displaying, so future changes of mappings will take affect right away.

Also changes the way how map is generating, ie. autogenerate from pygments lexers, and than complete with user defined mappings.

rhodecode/controllers/summary.py

@@ -1,176 +1,183 b''
 # -*- coding: utf-8 -*-
 """
     rhodecode.controllers.summary
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
     Summary controller for Rhodecode
 
     :created_on: Apr 18, 2010
     :author: marcink
     :copyright: (C) 2009-2011 Marcin Kuzminski <[e-mail]>
     :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 calendar
 import logging
 from time import mktime
 from datetime import datetime, timedelta, date
 
 from vcs.exceptions import ChangesetError
 
 from pylons import tmpl_context as c, request, url
 from pylons.i18n.translation import _
 
 from rhodecode.model.db import Statistics, Repository
 from rhodecode.model.repo import RepoModel
 
 from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator
 from rhodecode.lib.base import BaseRepoController, render
 from rhodecode.lib.utils import OrderedDict, EmptyChangeset
 
 from rhodecode.lib.celerylib import run_task
-from rhodecode.lib.celerylib.tasks import get_commits_stats
+from rhodecode.lib.celerylib.tasks import get_commits_stats, \
+    LANGUAGES_EXTENSIONS_MAP
 from rhodecode.lib.helpers import RepoPage
 
 try:
     import json
 except ImportError:
     #python 2.5 compatibility
     import simplejson as json
 log = logging.getLogger(__name__)
 
 
 class SummaryController(BaseRepoController):
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     def __before__(self):
         super(SummaryController, self).__before__()
 
     def index(self, repo_name):
 
         e = request.environ
         c.dbrepo = dbrepo = Repository.by_repo_name(repo_name)
 
         c.following = self.scm_model.is_following_repo(repo_name,
                                                 self.rhodecode_user.user_id)
 
         def url_generator(**kw):
             return url('shortlog_home', repo_name=repo_name, **kw)
 
         c.repo_changesets = RepoPage(c.rhodecode_repo, page=1,
                                      items_per_page=10, url=url_generator)
 
         if self.rhodecode_user.username == 'default':
             #for default(anonymous) user we don't need to pass credentials
             username = ''
             password = ''
         else:
             username = str(self.rhodecode_user.username)
             password = '@'
 
         uri = u'%(proto)s://%(user)s%(pass)s%(host)s%(prefix)s/%(repo_name)s' \
                                     % {'proto': e.get('wsgi.url_scheme'),
                                        'user': username,
                                        'pass': password,
                                        'host': e.get('HTTP_HOST'),
                                        'prefix': e.get('SCRIPT_NAME'),
                                        'repo_name': repo_name, }
         c.clone_repo_url = uri
         c.repo_tags = OrderedDict()
         for name, hash in c.rhodecode_repo.tags.items()[:10]:
             try:
                 c.repo_tags[name] = c.rhodecode_repo.get_changeset(hash)
             except ChangesetError:
                 c.repo_tags[name] = EmptyChangeset(hash)
 
         c.repo_branches = OrderedDict()
         for name, hash in c.rhodecode_repo.branches.items()[:10]:
             try:
                 c.repo_branches[name] = c.rhodecode_repo.get_changeset(hash)
             except ChangesetError:
                 c.repo_branches[name] = EmptyChangeset(hash)
 
         td = date.today() + timedelta(days=1)
         td_1m = td - timedelta(days=calendar.mdays[td.month])
         td_1y = td - timedelta(days=365)
 
         ts_min_m = mktime(td_1m.timetuple())
         ts_min_y = mktime(td_1y.timetuple())
         ts_max_y = mktime(td.timetuple())
 
         if dbrepo.enable_statistics:
             c.no_data_msg = _('No data loaded yet')
             run_task(get_commits_stats, c.dbrepo.repo_name, ts_min_y, ts_max_y)
         else:
             c.no_data_msg = _('Statistics are disabled for this repository')
         c.ts_min = ts_min_m
         c.ts_max = ts_max_y
 
         stats = self.sa.query(Statistics)\
             .filter(Statistics.repository == dbrepo)\
             .scalar()
 
         c.stats_percentage = 0
 
         if stats and stats.languages:
             c.no_data = False is dbrepo.enable_statistics
             lang_stats = json.loads(stats.languages)
             c.commit_data = stats.commit_activity
             c.overview_data = stats.commit_activity_combined
+
+            lang_stats = [(x, {"count":y,
+                               "desc":LANGUAGES_EXTENSIONS_MAP.get(x)})
+                          for x, y in lang_stats.items()]
+            print lang_stats
+
             c.trending_languages = json.dumps(OrderedDict(
-                                       sorted(lang_stats.items(), reverse=True,
+                                       sorted(lang_stats, reverse=True,
                                             key=lambda k: k[1])[:10]
                                         )
                                     )
             last_rev = stats.stat_on_revision
             c.repo_last_rev = c.rhodecode_repo.count() - 1 \
                 if c.rhodecode_repo.revisions else 0
             if last_rev == 0 or c.repo_last_rev == 0:
                 pass
             else:
                 c.stats_percentage = '%.2f' % ((float((last_rev)) /
                                                 c.repo_last_rev) * 100)
         else:
             c.commit_data = json.dumps({})
             c.overview_data = json.dumps([[ts_min_y, 0], [ts_max_y, 10]])
             c.trending_languages = json.dumps({})
             c.no_data = True
 
         c.enable_downloads = dbrepo.enable_downloads
         if c.enable_downloads:
             c.download_options = self._get_download_links(c.rhodecode_repo)
 
         return render('summary/summary.html')
 
     def _get_download_links(self, repo):
 
         download_l = []
 
         branches_group = ([], _("Branches"))
         tags_group = ([], _("Tags"))
 
         for name, chs in c.rhodecode_repo.branches.items():
             #chs = chs.split(':')[-1]
             branches_group[0].append((chs, name),)
         download_l.append(branches_group)
 
         for name, chs in c.rhodecode_repo.tags.items():
             #chs = chs.split(':')[-1]
             tags_group[0].append((chs, name),)
         download_l.append(tags_group)
 
         return download_l

rhodecode/lib/celerylib/tasks.py

@@ -1,404 +1,393 b''
 # -*- coding: utf-8 -*-
 """
     rhodecode.lib.celerylib.tasks
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
     RhodeCode task modules, containing all task that suppose to be run
     by celery daemon
 
     :created_on: Oct 6, 2010
     :author: marcink
     :copyright: (C) 2009-2011 Marcin Kuzminski <[e-mail]>
     :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/>.
 from celery.decorators import task
 
 import os
 import traceback
 import logging
 
 from time import mktime
 from operator import itemgetter
+from pygments import lexers
+from string import lower
 
 from pylons import config
 from pylons.i18n.translation import _
 
 from rhodecode.lib.celerylib import run_task, locked_task, str2bool
 from rhodecode.lib.helpers import person
 from rhodecode.lib.smtp_mailer import SmtpMailer
 from rhodecode.lib.utils import OrderedDict, add_cache
 from rhodecode.model import init_model
 from rhodecode.model import meta
 from rhodecode.model.db import RhodeCodeUi
 
 from vcs.backends import get_repo
 
 from sqlalchemy import engine_from_config
 
 add_cache(config)
 
 try:
     import json
 except ImportError:
     #python 2.5 compatibility
     import simplejson as json
 
 __all__ = ['whoosh_index', 'get_commits_stats',
            'reset_user_password', 'send_email']
 
 CELERY_ON = str2bool(config['app_conf'].get('use_celery'))
 
+LANGUAGES_EXTENSIONS_MAP = {}
+
+
+def __clean(s):
+
+    s = s.lstrip('*')
+    s = s.lstrip('.')
+
+    if s.find('[') != -1:
+        exts = []
+        start, stop = s.find('['), s.find(']')
+
+        for suffix in s[start + 1:stop]:
+            exts.append(s[:s.find('[')] + suffix)
+        return map(lower, exts)
+    else:
+        return map(lower, [s])
+
+for lx, t in sorted(lexers.LEXERS.items()):
+    m = map(__clean, t[-2])
+    if m:
+        m = reduce(lambda x, y: x + y, m)
+        for ext in m:
+            desc = lx.replace('Lexer', '')
+            if ext in LANGUAGES_EXTENSIONS_MAP:
+                if desc not in LANGUAGES_EXTENSIONS_MAP[ext]:
+                    LANGUAGES_EXTENSIONS_MAP[ext].append(desc)
+            else:
+                LANGUAGES_EXTENSIONS_MAP[ext] = [desc]
+
+#Additional mappings that are not present in the pygments lexers
+# NOTE: that this will overide any mappings in LANGUAGES_EXTENSIONS_MAP
+ADDITIONAL_MAPPINGS = {'xaml': 'XAML'}
+
+LANGUAGES_EXTENSIONS_MAP.update(ADDITIONAL_MAPPINGS)
+
+
 def get_session():
     if CELERY_ON:
         engine = engine_from_config(config, 'sqlalchemy.db1.')
         init_model(engine)
     sa = meta.Session()
     return sa
 
+
 def get_repos_path():
     sa = get_session()
     q = sa.query(RhodeCodeUi).filter(RhodeCodeUi.ui_key == '/').one()
     return q.ui_value
 
+
 @task(ignore_result=True)
 @locked_task
 def whoosh_index(repo_location, full_index):
     #log = whoosh_index.get_logger()
     from rhodecode.lib.indexers.daemon import WhooshIndexingDaemon
     index_location = config['index_dir']
     WhooshIndexingDaemon(index_location=index_location,
                          repo_location=repo_location, sa=get_session())\
                          .run(full_index=full_index)
 
+
 @task(ignore_result=True)
 @locked_task
 def get_commits_stats(repo_name, ts_min_y, ts_max_y):
     try:
         log = get_commits_stats.get_logger()
     except:
         log = logging.getLogger(__name__)
 
     from rhodecode.model.db import Statistics, Repository
 
     #for js data compatibilty
-    author_key_cleaner = lambda k: person(k).replace('"', "")
+    akc = lambda k: person(k).replace('"', "")
 
-    commits_by_day_author_aggregate = {}
+    co_day_auth_aggr = {}
     commits_by_day_aggregate = {}
     repos_path = get_repos_path()
     p = os.path.join(repos_path, repo_name)
     repo = get_repo(p)
 
     skip_date_limit = True
     parse_limit = int(config['app_conf'].get('commit_parse_limit'))
     last_rev = 0
     last_cs = None
     timegetter = itemgetter('time')
 
     sa = get_session()
 
     dbrepo = sa.query(Repository)\
         .filter(Repository.repo_name == repo_name).scalar()
     cur_stats = sa.query(Statistics)\
         .filter(Statistics.repository == dbrepo).scalar()
 
     if cur_stats is not None:
         last_rev = cur_stats.stat_on_revision
 
     #return if repo is empty
     if not repo.revisions:
         return True
 
     if last_rev == repo.get_changeset().revision and len(repo.revisions) > 1:
         #pass silently without any work if we're not on first revision or
         #current state of parsing revision(from db marker) is the last revision
         return True
 
     if cur_stats:
         commits_by_day_aggregate = OrderedDict(
                                        json.loads(
                                         cur_stats.commit_activity_combined))
-        commits_by_day_author_aggregate = json.loads(cur_stats.commit_activity)
+        co_day_auth_aggr = json.loads(cur_stats.commit_activity)
 
     log.debug('starting parsing %s', parse_limit)
     lmktime = mktime
 
     last_rev = last_rev + 1 if last_rev > 0 else last_rev
 
     for cs in repo[last_rev:last_rev + parse_limit]:
-        last_cs = cs #remember last parsed changeset
+        last_cs = cs  # remember last parsed changeset
         k = lmktime([cs.date.timetuple()[0], cs.date.timetuple()[1],
                       cs.date.timetuple()[2], 0, 0, 0, 0, 0, 0])
 
-        if commits_by_day_author_aggregate.has_key(author_key_cleaner(cs.author)):
+        if akc(cs.author) in co_day_auth_aggr:
             try:
-                l = [timegetter(x) for x in commits_by_day_author_aggregate\
-                        [author_key_cleaner(cs.author)]['data']]
+                l = [timegetter(x) for x in
+                     co_day_auth_aggr[akc(cs.author)]['data']]
                 time_pos = l.index(k)
             except ValueError:
                 time_pos = False
 
             if time_pos >= 0 and time_pos is not False:
 
-                datadict = commits_by_day_author_aggregate\
-                    [author_key_cleaner(cs.author)]['data'][time_pos]
+                datadict = co_day_auth_aggr[akc(cs.author)]['data'][time_pos]
 
                 datadict["commits"] += 1
                 datadict["added"] += len(cs.added)
                 datadict["changed"] += len(cs.changed)
                 datadict["removed"] += len(cs.removed)
 
             else:
                 if k >= ts_min_y and k <= ts_max_y or skip_date_limit:
 
-                    datadict = {"time":k,
-                                "commits":1,
-                                "added":len(cs.added),
-                                "changed":len(cs.changed),
-                                "removed":len(cs.removed),
+                    datadict = {"time": k,
+                                "commits": 1,
+                                "added": len(cs.added),
+                                "changed": len(cs.changed),
+                                "removed": len(cs.removed),
                                }
-                    commits_by_day_author_aggregate\
-                        [author_key_cleaner(cs.author)]['data'].append(datadict)
+                    co_day_auth_aggr[akc(cs.author)]['data']\
+                        .append(datadict)
 
         else:
             if k >= ts_min_y and k <= ts_max_y or skip_date_limit:
-                commits_by_day_author_aggregate[author_key_cleaner(cs.author)] = {
-                                    "label":author_key_cleaner(cs.author),
-                                    "data":[{"time":k,
+                co_day_auth_aggr[akc(cs.author)] = {
+                                    "label": akc(cs.author),
+                                    "data": [{"time":k,
                                              "commits":1,
                                              "added":len(cs.added),
                                              "changed":len(cs.changed),
                                              "removed":len(cs.removed),
                                              }],
-                                    "schema":["commits"],
+                                    "schema": ["commits"],
                                     }
 
         #gather all data by day
-        if commits_by_day_aggregate.has_key(k):
+        if k in commits_by_day_aggregate:
             commits_by_day_aggregate[k] += 1
         else:
             commits_by_day_aggregate[k] = 1
 
     overview_data = sorted(commits_by_day_aggregate.items(), key=itemgetter(0))
-    if not commits_by_day_author_aggregate:
-        commits_by_day_author_aggregate[author_key_cleaner(repo.contact)] = {
-            "label":author_key_cleaner(repo.contact),
-            "data":[0, 1],
-            "schema":["commits"],
+    if not co_day_auth_aggr:
+        co_day_auth_aggr[akc(repo.contact)] = {
+            "label": akc(repo.contact),
+            "data": [0, 1],
+            "schema": ["commits"],
         }
 
     stats = cur_stats if cur_stats else Statistics()
-    stats.commit_activity = json.dumps(commits_by_day_author_aggregate)
+    stats.commit_activity = json.dumps(co_day_auth_aggr)
     stats.commit_activity_combined = json.dumps(overview_data)
 
     log.debug('last revison %s', last_rev)
     leftovers = len(repo.revisions[last_rev:])
     log.debug('revisions to parse %s', leftovers)
 
     if last_rev == 0 or leftovers < parse_limit:
         log.debug('getting code trending stats')
         stats.languages = json.dumps(__get_codes_stats(repo_name))
 
     try:
         stats.repository = dbrepo
         stats.stat_on_revision = last_cs.revision if last_cs else 0
         sa.add(stats)
         sa.commit()
     except:
         log.error(traceback.format_exc())
         sa.rollback()
         return False
     if len(repo.revisions) > 1:
         run_task(get_commits_stats, repo_name, ts_min_y, ts_max_y)
 
     return True
 
+
 @task(ignore_result=True)
 def reset_user_password(user_email):
     try:
         log = reset_user_password.get_logger()
     except:
         log = logging.getLogger(__name__)
 
     from rhodecode.lib import auth
     from rhodecode.model.db import User
 
     try:
         try:
             sa = get_session()
             user = sa.query(User).filter(User.email == user_email).scalar()
             new_passwd = auth.PasswordGenerator().gen_password(8,
                              auth.PasswordGenerator.ALPHABETS_BIG_SMALL)
             if user:
                 user.password = auth.get_crypt_password(new_passwd)
                 user.api_key = auth.generate_api_key(user.username)
                 sa.add(user)
                 sa.commit()
                 log.info('change password for %s', user_email)
             if new_passwd is None:
                 raise Exception('unable to generate new password')
 
         except:
             log.error(traceback.format_exc())
             sa.rollback()
 
         run_task(send_email, user_email,
                  "Your new rhodecode password",
                  'Your new rhodecode password:%s' % (new_passwd))
         log.info('send new password mail to %s', user_email)
 
-
     except:
         log.error('Failed to update user password')
         log.error(traceback.format_exc())
 
     return True
 
+
 @task(ignore_result=True)
 def send_email(recipients, subject, body):
     """
     Sends an email with defined parameters from the .ini files.
 
 
     :param recipients: list of recipients, it this is empty the defined email
         address from field 'email_to' is used instead
     :param subject: subject of the mail
     :param body: body of the mail
     """
     try:
         log = send_email.get_logger()
     except:
         log = logging.getLogger(__name__)
 
     email_config = config
 
     if not recipients:
         recipients = [email_config.get('email_to')]
 
     mail_from = email_config.get('app_email_from')
     user = email_config.get('smtp_username')
     passwd = email_config.get('smtp_password')
     mail_server = email_config.get('smtp_server')
     mail_port = email_config.get('smtp_port')
     tls = str2bool(email_config.get('smtp_use_tls'))
     ssl = str2bool(email_config.get('smtp_use_ssl'))
     debug = str2bool(config.get('debug'))
 
     try:
         m = SmtpMailer(mail_from, user, passwd, mail_server,
                        mail_port, ssl, tls, debug=debug)
         m.send(recipients, subject, body)
     except:
         log.error('Mail sending failed')
         log.error(traceback.format_exc())
         return False
     return True
 
+
 @task(ignore_result=True)
 def create_repo_fork(form_data, cur_user):
     try:
         log = create_repo_fork.get_logger()
     except:
         log = logging.getLogger(__name__)
 
     from rhodecode.model.repo import RepoModel
     from vcs import get_backend
 
     repo_model = RepoModel(get_session())
     repo_model.create(form_data, cur_user, just_db=True, fork=True)
     repo_name = form_data['repo_name']
     repos_path = get_repos_path()
     repo_path = os.path.join(repos_path, repo_name)
     repo_fork_path = os.path.join(repos_path, form_data['fork_name'])
     alias = form_data['repo_type']
 
     log.info('creating repo fork %s as %s', repo_name, repo_path)
     backend = get_backend(alias)
     backend(str(repo_fork_path), create=True, src_url=str(repo_path))
 
+
 def __get_codes_stats(repo_name):
-    LANGUAGES_EXTENSIONS_MAP = {'scm': 'Scheme', 'asmx': 'VbNetAspx', 'Rout':
-    'RConsole', 'rest': 'Rst', 'abap': 'ABAP', 'go': 'Go', 'phtml': 'HtmlPhp',
-    'ns2': 'Newspeak', 'xml': 'EvoqueXml', 'sh-session': 'BashSession', 'ads':
-    'Ada', 'clj': 'Clojure', 'll': 'Llvm', 'ebuild': 'Bash', 'adb': 'Ada',
-    'ada': 'Ada', 'c++-objdump': 'CppObjdump', 'aspx':
-    'VbNetAspx', 'ksh': 'Bash', 'coffee': 'CoffeeScript', 'vert': 'GLShader',
-    'Makefile.*': 'Makefile', 'di': 'D', 'dpatch': 'DarcsPatch', 'rake':
-    'Ruby', 'moo': 'MOOCode', 'erl-sh': 'ErlangShell', 'geo': 'GLShader',
-    'pov': 'Povray', 'bas': 'VbNet', 'bat': 'Batch', 'd': 'D', 'lisp':
-    'CommonLisp', 'h': 'C', 'rbx': 'Ruby', 'tcl': 'Tcl', 'c++': 'Cpp', 'md':
-    'MiniD', '.vimrc': 'Vim', 'xsd': 'Xml', 'ml': 'Ocaml', 'el': 'CommonLisp',
-    'befunge': 'Befunge', 'xsl': 'Xslt', 'pyx': 'Cython', 'cfm':
-    'ColdfusionHtml', 'evoque': 'Evoque', 'cfg': 'Ini', 'htm': 'Html',
-    'Makefile': 'Makefile', 'cfc': 'ColdfusionHtml', 'tex': 'Tex', 'cs':
-    'CSharp', 'mxml': 'Mxml', 'patch': 'Diff', 'apache.conf': 'ApacheConf',
-    'scala': 'Scala', 'applescript': 'AppleScript', 'GNUmakefile': 'Makefile',
-    'c-objdump': 'CObjdump', 'lua': 'Lua', 'apache2.conf': 'ApacheConf', 'rb':
-    'Ruby', 'gemspec': 'Ruby', 'rl': 'RagelObjectiveC', 'vala': 'Vala', 'tmpl':
-    'Cheetah', 'bf': 'Brainfuck', 'plt': 'Gnuplot', 'G': 'AntlrRuby', 'xslt':
-    'Xslt', 'flxh': 'Felix', 'asax': 'VbNetAspx', 'Rakefile': 'Ruby', 'S': 'S',
-    'wsdl': 'Xml', 'js': 'Javascript', 'autodelegate': 'Myghty', 'properties':
-    'Ini', 'bash': 'Bash', 'c': 'C', 'g': 'AntlrRuby', 'r3': 'Rebol', 's':
-    'Gas', 'ashx': 'VbNetAspx', 'cxx': 'Cpp', 'boo': 'Boo', 'prolog': 'Prolog',
-    'sqlite3-console': 'SqliteConsole', 'cl': 'CommonLisp', 'cc': 'Cpp', 'pot':
-    'Gettext', 'vim': 'Vim', 'pxi': 'Cython', 'yaml': 'Yaml', 'SConstruct':
-    'Python', 'diff': 'Diff', 'txt': 'Text', 'cw': 'Redcode', 'pxd': 'Cython',
-    'plot': 'Gnuplot', 'java': 'Java', 'hrl': 'Erlang', 'py': 'Python',
-    'makefile': 'Makefile', 'squid.conf': 'SquidConf', 'asm': 'Nasm', 'toc':
-    'Tex', 'kid': 'Genshi', 'rhtml': 'Rhtml', 'po': 'Gettext', 'pl': 'Prolog',
-    'pm': 'Perl', 'hx': 'Haxe', 'ascx': 'VbNetAspx', 'ooc': 'Ooc', 'asy':
-    'Asymptote', 'hs': 'Haskell', 'SConscript': 'Python', 'pytb':
-    'PythonTraceback', 'myt': 'Myghty', 'hh': 'Cpp', 'R': 'S', 'aux': 'Tex',
-    'rst': 'Rst', 'cpp-objdump': 'CppObjdump', 'lgt': 'Logtalk', 'rss': 'Xml',
-    'flx': 'Felix', 'b': 'Brainfuck', 'f': 'Fortran', 'rbw': 'Ruby',
-    '.htaccess': 'ApacheConf', 'cxx-objdump': 'CppObjdump', 'j': 'ObjectiveJ',
-    'mll': 'Ocaml', 'yml': 'Yaml', 'mu': 'MuPAD', 'r': 'Rebol', 'ASM': 'Nasm',
-    'erl': 'Erlang', 'mly': 'Ocaml', 'mo': 'Modelica', 'def': 'Modula2', 'ini':
-    'Ini', 'control': 'DebianControl', 'vb': 'VbNet', 'vapi': 'Vala', 'pro':
-    'Prolog', 'spt': 'Cheetah', 'mli': 'Ocaml', 'as': 'ActionScript3', 'cmd':
-    'Batch', 'cpp': 'Cpp', 'io': 'Io', 'tac': 'Python', 'haml': 'Haml', 'rkt':
-    'Racket', 'st':'Smalltalk', 'inc': 'Povray', 'pas': 'Delphi', 'cmake':
-    'CMake', 'csh':'Tcsh', 'hpp': 'Cpp', 'feature': 'Gherkin', 'html': 'Html',
-    'php':'Php', 'php3':'Php', 'php4':'Php', 'php5':'Php', 'xhtml': 'Html',
-    'hxx': 'Cpp', 'eclass': 'Bash', 'css': 'Css',
-    'frag': 'GLShader', 'd-objdump': 'DObjdump', 'weechatlog': 'IrcLogs',
-    'tcsh': 'Tcsh', 'objdump': 'Objdump', 'pyw': 'Python', 'h++': 'Cpp',
-    'py3tb': 'Python3Traceback', 'jsp': 'Jsp', 'sql': 'Sql', 'mak': 'Makefile',
-    'php': 'Php', 'mao': 'Mako', 'man': 'Groff', 'dylan': 'Dylan', 'sass':
-    'Sass', 'cfml': 'ColdfusionHtml', 'darcspatch': 'DarcsPatch', 'tpl':
-    'Smarty', 'm': 'ObjectiveC', 'f90': 'Fortran', 'mod': 'Modula2', 'sh':
-    'Bash', 'lhs': 'LiterateHaskell', 'sources.list': 'SourcesList', 'axd':
-    'VbNetAspx', 'sc': 'Python'}
-
     repos_path = get_repos_path()
     p = os.path.join(repos_path, repo_name)
     repo = get_repo(p)
     tip = repo.get_changeset()
     code_stats = {}
 
     def aggregate(cs):
         for f in cs[2]:
-            ext = f.extension
-            key = LANGUAGES_EXTENSIONS_MAP.get(ext, ext)
-            key = key or ext
+            ext = lower(f.extension)
             if ext in LANGUAGES_EXTENSIONS_MAP.keys() and not f.is_binary:
-                if code_stats.has_key(key):
-                    code_stats[key] += 1
+                if ext in code_stats:
+                    code_stats[ext] += 1
                 else:
-                    code_stats[key] = 1
+                    code_stats[ext] = 1
 
     map(aggregate, tip.walk('/'))
 
     return code_stats or {}

rhodecode/templates/summary/summary.html

@@ -1,704 +1,704 b''
 <%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('/'))}
     &raquo; 
     ${h.link_to(c.dbrepo.just_name,h.url('summary_home',repo_name=c.repo_name))}
     &raquo;
     ${_('summary')}
 </%def>
 
 <%def name="page_nav()">
 	${self.menu('summary')}    
 </%def>
 
 <%def name="main()">
 <div class="box box-left">
     <!-- box / title -->
     <div class="title">
         ${self.breadcrumbs()}
     </div>
     <!-- end box / title -->
 	<div class="form">
 	  <div class="fields">
 		 
 			 <div class="field">
 			  <div class="label">
 			      <label>${_('Name')}:</label>
 			  </div>
 			  <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')}"
                             onclick="javascript:toggleFollowingRepo(this,${c.dbrepo.repo_id},'${str(h.get_token())}')">
                       </span>
                       %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")}"/>
 		         %endif
 		         %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")}"/>
 		         %endif 
                             
                  ##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")}"/>
 	             %else:
 	                <img style="margin-bottom:2px" class="icon" title="${_('public repository')}" alt="${_('public repository')}" src="${h.url("/images/icons/lock_open.png")}"/>
 	             %endif
 	             
 	              ##REPO NAME
 			      <span style="font-size: 1.6em;font-weight: bold;vertical-align: baseline;clear:right">${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>
 	            	</div>
 		          %endif
 		          ##REMOTE
 				  %if c.dbrepo.clone_uri:
                     <div style="margin-top:5px;clear:both">
                     <a href="${h.url(str(c.dbrepo.clone_uri))}">
                     <img class="icon" alt="${_('remote clone')}"
                     title="${_('Clone from')} ${c.dbrepo.clone_uri}" 
                     src="${h.url("/images/icons/connect.png")}"/>
                     ${_('Clone from')} ${c.dbrepo.clone_uri}
                     </a>
                     </div>					
 				  %endif		            		      
 			  </div>
 			 </div>
 			
 			
 			 <div class="field">
 			  <div class="label">
 			      <label>${_('Description')}:</label>
 			  </div>
 			  <div class="input-short">
 			      ${c.dbrepo.description}
 			  </div>
 			 </div>
 			
 			
 			 <div class="field">
 			  <div class="label">
 			      <label>${_('Contact')}:</label>
 			  </div>
 			  <div class="input-short">
 			  	<div class="gravatar">
 			  		<img alt="gravatar" src="${h.gravatar_url(c.dbrepo.user.email)}"/>
 			  	</div>
 			  		${_('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>
 			  </div>
 			 </div>
 			
 			 <div class="field">
 			  <div class="label">
 			      <label>${_('Last change')}:</label>
 			  </div>
 			  <div class="input-short">
                   <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} 
 			      
 			  </div>
 			 </div>
 			
 			 <div class="field">
 			  <div class="label">
 			      <label>${_('Clone url')}:</label>
 			  </div>
 			  <div class="input-short">
 			      <input type="text" id="clone_url" readonly="readonly" value="hg clone ${c.clone_repo_url}" size="70"/>
 			  </div>
 			 </div>
 			 
 			 <div class="field">
 			  <div class="label">
 			      <label>${_('Trending source files')}:</label>
 			  </div>
 			  <div class="input-short">
 			    <div id="lang_stats"></div> 			   
 			  </div>
 			 </div>
 			 			
 			 <div class="field">
 			  <div class="label">
 			      <label>${_('Download')}:</label>
 			  </div>
 			  <div class="input-short">
 		        %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))}]
                     %endif  		          
 		        %else:
 			        ${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:
 			             |
 			             %endif
 			             <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
 			    %endif
 			  </div>
 			 </div>
 			 
 			 <div class="field">
 			  <div class="label">
 			      <label>${_('Feeds')}:</label>
 			  </div>
 			  <div class="input-short">
 			   %if c.rhodecode_user.username != 'default':
 	            ${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')}
 	           %else:
                 ${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')}	           
 	           %endif 
 			  </div>
 			 </div>				 			 			 
 	  </div>		 
 	</div>
   	<script type="text/javascript">
 	  	YUE.onDOMReady(function(e){
 	  	    id = 'clone_url';
 	  	    YUE.on(id,'click',function(e){
 	  	        YUD.get('clone_url').select();
 	  	    })
 	  	})
   		var data = ${c.trending_languages|n};
   		var total = 0;
   		var no_data = true;
   		for (k in data){
-  		    total += data[k];
+  		    total += data[k].count;
   		    no_data = false;
   		} 
 		var tbl = document.createElement('table');
 		tbl.setAttribute('class','trending_language_tbl');
-		var cnt =0;
+		var cnt = 0;
   		for (k in data){
-  			cnt+=1;
+  			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]/total*100),2);
-			var value = data[k];
+	  		var percentage = Math.round((data[k].count/total*100),2);
+			var value = data[k].count;
 	  		var td1 = document.createElement('td');
-	  		td1.width=150;
+	  		td1.width = 150;
 	  		var trending_language_label = document.createElement('div');
-	  		trending_language_label.innerHTML = k;
+	  		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>20){
+  		    if (percentage>22){
   		    	trending_language.innerHTML = "<b style='font-size:0.8em'>"+percentage+"% "+nr_files+ "</b>";	
   		    }
   		    else{
   		    	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 == 2){
   		    	var show_more = document.createElement('tr');
   		    	var td=document.createElement('td');
   		    	lnk = document.createElement('a');
   		    	lnk.href='#';
-  		    	lnk.innerHTML = "${_("show more")}";
+  		    	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){
   			var tr = document.createElement('tr');
   			var td1 = document.createElement('td');
   			td1.innerHTML = "${c.no_data_msg}";
   			tr.appendChild(td1);
   			tbl.appendChild(tr);
 		}
   		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 = {}
                  %for cnt,archive in enumerate(c.rhodecode_repo._get_archives()):
                 	 tmpl_links['${archive['type']}'] = '${h.link_to(archive['type'],
                         h.url('files_archive_home',repo_name=c.dbrepo.repo_name,
                         fname='__CS__'+archive['extension']),class_="archive_icon")}';
                  %endfor
                 
                  
                  for(k in tmpl_links){
                 	 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);
                  }
                  
              })
              	
   	</script>    				
 </div>
         
 <div class="box box-right"  style="min-height:455px">
     <!-- box / title -->
     <div class="title">
         <h5>${_('Commit activity by day / author')}</h5>
     </div>
     
     <div class="table">
          <div style="padding:0 10px 10px 15px;font-size: 1.2em;">
          %if c.no_data:
            ${c.no_data_msg}
            %if h.HasPermissionAll('hg.admin')('enable stats on from summary'):
                 [${h.link_to(_('enable'),h.url('edit_repo',repo_name=c.repo_name))}]
            %endif         
            
         %else:
             ${_('Loaded in')} ${c.stats_percentage} %
         %endif
         </div>  
         <div id="commit_history" style="width:460px;height:300px;float:left"></div>
         <div style="clear: both;height: 10px"></div>
         <div id="overview" style="width:460px;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>
 	    	</div>
     	</div>
 		<script type="text/javascript">
 		/**
 		 * 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 keys = [];
 				for(var key in dataset){
 					var push = false;
 					
 					//method1 slow !!
 		            //*
 		            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){
 			            	push = true;
 			            	break;
 					    }
 				    }
 					//*/
 				    
 				    /*//method2 sorted commit data !!!
 				    
 				    var first_commit = dataset[key].data[0].time;
 				    var last_commit = dataset[key].data[dataset[key].data.length-1].time;
 				    
 				    if (first_commit >= ranges.xaxis.from && last_commit <= ranges.xaxis.to){
 						push = true;
 					}
 				    //*/
 				    
 				    if(push){			
 				    	data.push(dataset[key]);
 				    }
 				}
 				if(data.length >= 1){
 					return data;
 				} 
 				else{
 					//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]);
 							}
 						}			                
 	    	        }
 	                else{
 		                //push dummy data to not hide the label
 						new_data.push(getDummyData(checkbox_key));
 			        }
 		        }
 					        
 		    	var new_options = YAHOO.lang.merge(plot_options, {
 		            xaxis: { 
 		  	      		min: cur_ranges.xaxis.from, 
 		  	      		max: cur_ranges.xaxis.to,
 		  	      		mode:"time",
 		  	      		timeformat: "%d/%m",
 		        	},
 		    	});
 		    	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
 		     * @returns
 		     */
 		    function plotselected(ranges,cur_data) {
 			    //updates the data for new plot
 	    		data = getDataAccordingToRanges(ranges);
 	    		generateCheckboxes(data);
 	    		
 		    	var new_options = YAHOO.lang.merge(plot_options, {
 		            xaxis: { 
 		  	      		min: ranges.xaxis.from, 
 		  	      		max: ranges.xaxis.to,
 		  	      		mode:"time",
 		  	      		timeformat: "%d/%m",
 		        	},
 		        	yaxis: { 
                         min: ranges.yaxis.from, 
                         max: ranges.yaxis.to,
                     },
                     		        	
 		    	});
 		    	// do the zooming
 		        plot = YAHOO.widget.Flot(plotContainer, 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(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 {
 		        	  var tooltip = YUD.get("tooltip");
 		        	  
 			          if(tooltip) {
 			                tooltip.parentNode.removeChild(tooltip);
 			          }
 		            previousPoint = null;
 		        }
 		    }
 			
 		    /**
 		     * MAIN EXECUTION
 		     */
 			
 			var data = getDataAccordingToRanges(initial_ranges);
 			generateCheckboxes(data);
 			
 		    //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("plotselected", plotselected);
 		    
 		    overview.subscribe("plotselected", function (ranges) {
 		        plot.setSelection(ranges);
 		    });		
 				
 		    plot.subscribe("plothover", plothover);
 
 		    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});		
 		</script>
 
     </div>
 </div>    
 
 <div class="box">    
     <div class="title">
         <div class="breadcrumbs">${h.link_to(_('Shortlog'),h.url('shortlog_home',repo_name=c.repo_name))}</div>
     </div>    
     <div class="table">
         <div id="shortlog_data">
             <%include file='../shortlog/shortlog_data.html'/>
         </div>
         ##%if c.repo_changesets:
         ##	${h.link_to(_('show more'),h.url('changelog_home',repo_name=c.repo_name))}
         ##%endif
     </div>
 </div>
 <div class="box">    
     <div class="title">
         <div class="breadcrumbs">${h.link_to(_('Tags'),h.url('tags_home',repo_name=c.repo_name))}</div>
     </div>    
     <div class="table">
         <%include file='../tags/tags_data.html'/>
         %if c.repo_changesets:
         	${h.link_to(_('show more'),h.url('tags_home',repo_name=c.repo_name))}
         %endif
     </div>
 </div>
 <div class="box">
     <div class="title">
         <div class="breadcrumbs">${h.link_to(_('Branches'),h.url('branches_home',repo_name=c.repo_name))}</div>
     </div>    
     <div class="table">
         <%include file='../branches/branches_data.html'/>
         %if c.repo_changesets:
         	${h.link_to(_('show more'),h.url('branches_home',repo_name=c.repo_name))}
         %endif
     </div>      
 </div> 
 
 </%def>