upstream/kallithea Commit - r1818:cf51bbfb

rhodecode/config/routing.py

0 +1 -1

                     m.connect('repo_as_fork', "/repo_as_fork/{repo_name:.*}",
                               action="repo_as_fork", conditions=dict(method=["PUT"],
                                                                   function=check_repo))
                 with rmap.submapper(path_prefix=ADMIN_PREFIX,
                                     controller='admin/repos_groups') as m:
                     m.connect("repos_groups", "/repos_groups",

rhodecode/controllers/admin/notifications.py

0 +1 -1

                 """REST Controller styled on the Atom Publishing Protocol"""
                 # To properly map this controller, ensure your config/routing.py
                 # file has a resource setup:
                 #     map.resource('notification', 'notifications', controller='_admin/notifications',
                 #         path_prefix='/_admin', name_prefix='_admin_')
                 @LoginRequired()

rhodecode/controllers/admin/repos.py

0 +3 -3

                                                         c.repo_last_rev) * 100)
                     defaults = RepoModel()._get_defaults(repo_name)
                     c.repos_list = [('', _('--REMOVE FORK--'))]
                     c.repos_list += [(x.repo_id, x.repo_name) for x in
                                Repository.query().order_by(Repository.repo_name).all()]
                 def repo_as_fork(self, repo_name):
                     """
                     Mark given repository as a fork of another
                     :param repo_name:
                     """
                     try:
                                                 self.rhodecode_user.username)
                         fork = repo.fork.repo_name if repo.fork else _('Nothing')
                         Session.commit()
                         h.flash(_('Marked repo %s as fork of %s' % (repo_name,fork)),
                                 category='success')
                     except Exception, e:
                         raise

rhodecode/controllers/admin/repos_groups.py

0 0 -2

                         encoding="UTF-8",
                         force_defaults=False
                     )

rhodecode/controllers/admin/users.py

0 +1 -1

                     grant_perm = request.POST.get('create_repo_perm', False)
                     user_model = UserModel()
                     if grant_perm:
                         perm = Permission.get_by_key('hg.create.none')
                         user_model.revoke_perm(id, perm)

rhodecode/controllers/admin/users_groups.py

0 +3 -3

                     c.available_members = [(x.user_id, x.username) for x in
                                            self.sa.query(User).all()]
                     available_members = [safe_unicode(x[0]) for x in c.available_members]
                     users_group_form = UsersGroupForm(edit=True,
                                                       old_data=c.users_group.get_dict(),
                                                       available_members=available_members)()
                         UsersGroupModel().grant_perm(id, perm)
                         h.flash(_("Granted 'repository create' permission to user"),
                                 category='success')
                         Session.commit()
                     else:
                         perm = Permission.get_by_key('hg.create.repository')

rhodecode/controllers/api/__init__.py

0 +4 -5

                 :created_on: Aug 20, 2011
                 :author: marcink
                 :copyright: (C) 2009-2010 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; version 2
             # of the License or (at your opinion) any later version of the license.
+            #
             # 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, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
                     if self._error is not None:
                         raw_response = None
                     response = dict(id=self._req_id, result=raw_response,
                                     error=self._error)
                     try:
                         return func
                     else:
                         raise AttributeError("No such method: %s" % self._req_method)

rhodecode/controllers/bookmarks.py

0 +1 -1

                 def index(self):
                     if c.rhodecode_repo.alias != 'hg':
                         raise HTTPNotFound()
                     c.repo_bookmarks = OrderedDict()
                     bookmarks = [(name, c.rhodecode_repo.get_changeset(hash_)) for \

rhodecode/controllers/changelog.py

0 +4 -5

                     branch_name = request.params.get('branch', None)
                     try:
                         if branch_name:
                             collection = [z for z in
                                           c.rhodecode_repo.get_changesets(start=0,
                                                                 branch_name=branch_name)]
                             c.total_cs = len(collection)
                         else:
                             collection = list(c.rhodecode_repo)
                             c.total_cs = len(c.rhodecode_repo)
                         c.pagination = RepoPage(collection, page=p, item_count=c.total_cs,
                                                 items_per_page=c.size, branch=branch_name)
                     except (RepositoryError, ChangesetDoesNotExistError, Exception), e:
                         log.error(traceback.format_exc())
                         h.flash(str(e), category='warning')
                         return redirect(url('home'))
                     self._graph(c.rhodecode_repo, collection, c.total_cs, c.size, p)
                             data.append(['', vtx, edges])
                     c.jsdata = json.dumps(data)

rhodecode/controllers/files.py

0 +1 -2

                             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':
                         _d, _f = ScmModel().get_nodes(repo_name, cs.raw_id, f_path,
                                                       flat=False)
                         return _d + _f

rhodecode/controllers/home.py

0 0 -1

                         return render('/switch_to_list.html')
                     else:
                         return HTTPBadRequest()

rhodecode/controllers/login.py

0 +1 -1

                                      'session, session attrs %s' % (username, cs))
                             user.update_lastlogin()
                             Session.commit()
                             if c.came_from:
                                 return redirect(c.came_from)
                             else:

rhodecode/controllers/summary.py

0 0 -1

@@ -233,4 +233,3 b' class SummaryController(BaseRepoControll'
233	download_l.append(tags_group)	233	download_l.append(tags_group)
234		234
235	return download_l	235	return download_l
236

rhodecode/lib/__init__.py

0 +13 -13

             def convert_line_endings(line, mode):
                 """
                 Converts a given line  "line end" accordingly to given mode
                 Available modes are::
 - Unix
 - Mac
 - DOS
                 :param line: given line to convert
                 :param mode: mode to convert to
                 :rtype: str
             def safe_unicode(str_, from_encoding='utf8'):
                 """
                 safe unicode function. Does few trick to turn str_ into unicode
                 In case of UnicodeDecode error we try to return it with encoding detected
                 by chardet library if it fails fallback to unicode with errors replaced
             def safe_str(unicode_, to_encoding='utf8'):
                 """
                 safe str function. Does few trick to turn unicode_ into string
                 In case of UnicodeEncodeError we try to return it with encoding detected
                 by chardet library if it fails fallback to string with errors replaced
             def engine_from_config(configuration, prefix='sqlalchemy.', **kwargs):
                 """
                 Custom engine_from_config functions that makes sure we use NullPool for
                 file based sqlite databases. This prevents errors on sqlite. This only
                 applies to sqlalchemy versions < 0.7.0
                 """
             def age(curdate):
                 """
                 turns a datetime into an age string.
                 :param curdate: datetime object
                 :rtype: unicode
                 :returns: unicode words describing age
             def uri_filter(uri):
                 """
                 Removes user:password from given url string
                 :param uri:
                 :rtype: unicode
                 :returns: filtered list of strings
                 """
                 if not uri:
                     return ''
             def credentials_filter(uri):
                 """
                 Returns a url with removed credentials
                 :param uri:
                 """
             def get_changeset_safe(repo, rev):
                 """
                 Safe version of get_changeset if this changeset doesn't exists for a
                 repo it returns a Dummy one instead
                 :param repo:
                 :param rev:
                 """
                 """
                 Returns tuple of (number, id) from repository containing this package
                 or None if repository could not be found.
                 :param quiet: prints error for fetching revision if True
                 """
             def extract_mentioned_users(s):
                 """
                 Returns unique usernames from given string s that have @mention
                 :param s: string to get mentions
                 """
                 usrs = {}

rhodecode/lib/annotate.py

0 +2 -2

                 ~~~~~~~~~~~~~~~~~~~~~~
                 Anontation library for usage in rhodecode, previously part of vcs
                 :created_on: Dec 4, 2011
                 :author: marcink
                 :copyright: (C) 2009-2011 Marcin Kuzminski <marcin@python-works.com>
                 :license: GPLv3, see COPYING for more details.
             """

rhodecode/lib/auth.py

0 +8 -9

             class PasswordGenerator(object):
                 """
                 This is a simple class for generating password from different sets of
                 characters
                 usage::
             def generate_api_key(str_, salt=None):
                 """
                 Generates API KEY from given string
                 :param str_:
                 :param salt:
                 """
             def authfunc(environ, username, password):
                 """
                 Dummy authentication wrapper function used in Mercurial and Git for
                 access control.
                 :param environ: needed only for using in Basic auth
                             if user_model.create_ldap(username, password, user_dn,
                                                       user_attrs):
                                 log.info('created new ldap user %s', username)
                             Session.commit()
                             return True
                         except (LdapUsernameError, LdapPasswordError,):
                             pass
                 user.update_lastlogin()
                 Session.commit()
                 log.debug('User %s is now logged in by container authentication',
                           user.username)
                 return user
                     if self._api_key and self._api_key != self.anonymous_user.api_key:
                         log.debug('Auth User lookup by API KEY %s', self._api_key)
                         is_user_loaded = user_model.fill_data(self, api_key=self._api_key)
                     # lookup by userid
                     elif (self.user_id is not None and
                           self.user_id != self.anonymous_user.user_id):
                         log.debug('Auth User lookup by USER ID %s', self.user_id)
                     # lookup by username
                     elif self.username and \
                         str2bool(config.get('container_auth_enabled', False)):
                         log.debug('Auth User lookup by USER NAME %s', self.username)
                         dbuser = login_container_auth(self.username)
                         if dbuser is not None:
                         return True
                     log.debug('permission denied')
                     return False

rhodecode/lib/backup_manager.py

0 +1 -1

                 rhodecode.lib.backup_manager
                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
                 Mercurial repositories backup manager, it allows to backups all
                 repositories and send it to backup server using RSA key via ssh.
                 :created_on: Feb 28, 2010

rhodecode/lib/base.py

0 0 -1

@@ -175,4 +175,3 b' class BaseRepoController(BaseController)'
175		175
176	c.repository_followers = self.scm_model.get_followers(c.repo_name)	176	c.repository_followers = self.scm_model.get_followers(c.repo_name)
177	c.repository_forks = self.scm_model.get_forks(c.repo_name)	177	c.repository_forks = self.scm_model.get_forks(c.repo_name)
178

rhodecode/lib/celerylib/tasks.py

0 +4 -4

                     repo = Repository.get_by_repo_name(repo_name)
                     if repo is None:
                         return True
                     repo = repo.scm_instance
                     repo_size = repo.count()
                     # return if repo have no revisions
             def create_repo_fork(form_data, cur_user):
                 """
                 Creates a fork of repository using interval VCS methods
                 :param form_data:
                 :param cur_user:
                 """
                         update_after_clone=update_after_clone)
                 action_logger(cur_user, 'user_forked_repo:%s' % fork_name,
                                org_repo_name, '', Session)
                 action_logger(cur_user, 'user_created_fork:%s' % fork_name,
                                fork_name, '', Session)
                 # finally commit at latest possible stage
                 Session.commit()

rhodecode/lib/compat.py

0 +4 -4

                 ~~~~~~~~~~~~~~~~~~~~
                 Python backward compatibility functions and common libs
                 :created_on: Oct 7, 2011
                 :author: marcink
                 :copyright: (C) 2009-2010 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
             class _odict(object):
                 """Ordered dict data structure, with O(1) complexity for dict operations
                 that modify one element.
                 Overwriting values doesn't change their original sequential order.
                 """

rhodecode/lib/dbmigrate/migrate/__init__.py

0 +1 -1

             from rhodecode.lib.dbmigrate.migrate.versioning import *
             from rhodecode.lib.dbmigrate.migrate.changeset import *
-            __version__ = '0.7.3.dev'
  No newline at end of file
+            __version__ = '0.7.3.dev'

rhodecode/lib/dbmigrate/migrate/changeset/__init__.py

0 +1 -1

             warnings.simplefilter('always', DeprecationWarning)
             _sa_version = tuple(int(re.match("\d+", x).group(0))
                                 for x in _sa_version.split("."))
             SQLA_06 = _sa_version >= (0, 6)
             SQLA_07 = _sa_version >= (0, 7)

rhodecode/lib/dbmigrate/migrate/versioning/genmodel.py

0 0 -1

                             except:
                                 trans.rollback()
                                 raise

rhodecode/lib/dbmigrate/migrate/versioning/repository.py

0 +1 -1

                 def create_script(self, description, **k):
                     """API to :meth:`migrate.versioning.version.Collection.create_new_python_version`"""
                     k['use_timestamp_numbering'] = self.use_timestamp_numbering
                     self.versions.create_new_python_version(description, **k)

rhodecode/lib/dbmigrate/migrate/versioning/version.py

0 +6 -6

                     and store them in self.versions
                     """
                     super(Collection, self).__init__(path)
                     # Create temporary list of files, allowing skipped version numbers.
                     files = os.listdir(path)
                     if '1' in files:
                     script.PythonScript.create(filepath, **k)
                     self.versions[ver] = Version(ver, self.path, [filename])
                 def create_new_sql_version(self, database, description, **k):
                     """Create SQL files for new version"""
                     ver = self._next_ver_num(k.pop('use_timestamp_numbering', False))
                         filepath = self._version_path(filename)
                         script.SqlScript.create(filepath, **k)
                         self.versions[ver].add_script(filepath)
                 def version(self, vernum=None):
                     """Returns latest Version if vernum is not given.
                     Otherwise, returns wanted version"""
             class Version(object):
                 """A single version in a collection
                 :param vernum: Version Number
                 :param path: Path to script files
                 :param filelist: List of scripts
                 :type vernum: int, VerNum
                     for script in filelist:
                         self.add_script(os.path.join(path, script))
                 def script(self, database=None, operation=None):
                     """Returns SQL or Python Script"""
                     for db in (database, 'default'):
                 def _add_script_sql(self, path):
                     basename = os.path.basename(path)
                     match = self.SQL_FILENAME.match(basename)
                     if match:
                         basename = basename.replace('.sql', '')
                         parts = basename.split('_')

rhodecode/lib/dbmigrate/schema/__init__.py

0 +3 -3

                 Schemas for migrations
                 :created_on: Nov 1, 2011
                 :author: marcink
                 :copyright: (C) 2009-2010 Marcin Kuzminski <marcin@python-works.com>
                 :license: <name>, see LICENSE_FILE for more details.
             """

rhodecode/lib/dbmigrate/schema/db_1_1_0.py

0 +1 -1

                     self.cache_active = False
                 def __repr__(self):
-                    return "<CacheInvalidation('%s:%s')>" % (self.cache_id, self.cache_key)
  No newline at end of file
+                    return "<CacheInvalidation('%s:%s')>" % (self.cache_id, self.cache_key)

rhodecode/lib/dbmigrate/schema/db_1_2_0.py

0 +3 -4

                     Returns Invalidation object if this given key should be invalidated
                     None otherwise. `cache_active = False` means that this cache
                     state is not valid and needs to be invalidated
                     :param key:
                     """
                     return cls.query()\
                 def set_invalidate(cls, key):
                     """
                     Mark this Cache key for invalidation
                     :param key:
                     """
                 def set_valid(cls, key):
                     """
                     Mark this cache key as active and currently cached
                     :param key:
                     """
                     inv_obj = Session.query(CacheInvalidation)\
                 repository_id = Column('repository_id', String(250), primary_key=True)
                 repository_path = Column('repository_path', Text)
                 version = Column('version', Integer)

rhodecode/lib/dbmigrate/schema/db_1_3_0.py

0 +1 -1

             # 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/>.
  No newline at end of file
+            # along with this program.  If not, see <http://www.gnu.org/licenses/>.

rhodecode/lib/dbmigrate/versions/002_version_1_1_0.py

0 +1 -1

                 #==========================================================================
                 from rhodecode.lib.dbmigrate.schema.db_1_1_0 import UserFollowing
                 UserFollowing().__table__.create()
                 #==========================================================================
                 # Add table `cache_invalidation`
                 #==========================================================================

rhodecode/lib/dbmigrate/versions/003_version_1_2_0.py

0 +3 -3

                                     nullable=True, unique=False, default=None)
                 clone_uri.create(Repository().__table__)
                 #ADD downloads column#
                 enable_downloads = Column("downloads", Boolean(), nullable=True, unique=None, default=True)
                 enable_downloads.create(Repository().__table__)
                 from rhodecode.lib.dbmigrate.schema.db_1_2_0 import UserFollowing
                 follows_from = Column('follows_from', DateTime(timezone=False),
                                       nullable=True, unique=None,
                                       default=datetime.datetime.now)
                 follows_from.create(UserFollowing().__table__)

rhodecode/lib/dbmigrate/versions/004_version_1_3_0.py

0 +1 -1

                 Don't create your own engine; bind migrate_engine to your metadata
                 """
                 return

rhodecode/lib/helpers.py

0 +6 -6

                                                         self.items_per_page))
                         self.last_page = self.first_page + self.page_count - 1
                         # Make sure that the requested page number is the range of
                         # valid pages
                         if self.page > self.last_page:
                             self.page = self.last_page
                 """
                 Generates a html string for changed nodes in changeset page.
                 It limits the output to 30 entries
                 :param nodes: LazyNodesGenerator
                 """
                 if nodes:
                 """
                 Makes a breadcrumbs link to repo within a group
                 joins &raquo; on each group to create a fancy link
                 ex::
                     group >> subgroup >> repo
                 :param groups_and_repos:
                 """
                 groups, repo_name = groups_and_repos
                 """
                 Displays a fancy two colored bar for number of added/deleted
                 lines of code on file
                 :param stats: two element list of added/deleted lines of code
                 """
             def rst_w_mentions(source):
                 """
                 Wrapped rst renderer with @mention highlighting
                 :param source:
                 """
                 return literal('<div class="rst-block">%s</div>' %

rhodecode/lib/markup_renderer.py

0 +8 -9

                 rhodecode.lib.markup_renderer
                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
                 Renderer for markup languages with ability to parse using rst or markdown
                 :created_on: Oct 27, 2011
                 :author: marcink
                 :copyright: (C) 2009-2011 Marcin Kuzminski <marcin@python-works.com>
             class MarkupRenderer(object):
                 RESTRUCTUREDTEXT_DISALLOWED_DIRECTIVES = ['include', 'meta', 'raw']
                 MARKDOWN_PAT = re.compile(r'md|mkdn?|mdown|markdown',re.IGNORECASE)
                 RST_PAT = re.compile(r're?st',re.IGNORECASE)
                 PLAIN_PAT = re.compile(r'readme',re.IGNORECASE)
                 def __detect_renderer(self, source, filename=None):
                     """
                     runs detection of what renderer should be used for generating html
                     from a markup language
                     filename can be also explicitly a renderer name
                     :param source:
                     :param filename:
                     """
                     Renders a given filename using detected renderer
                     it detects renderers based on file extension or mimetype.
                     At last it will just do a simple html replacing new lines with <br/>
                     :param file_name:
                     :param source:
                     """
                 @classmethod
                 def rst_with_mentions(cls, source):
                     mention_pat = re.compile(r'(?:^@|\s@)(\w+)')
                     def wrapp(match_obj):
                         uname = match_obj.groups()[0]
                         return ' **@%(uname)s** ' % {'uname':uname}
                     mention_hl = mention_pat.sub(wrapp, source).strip()
                     return cls.rst(mention_hl)

rhodecode/lib/middleware/simplegit.py

0 +2 -2

                                 try:
                                     user = self.__get_user(username)
                                     if user is None or not user.active:
                                         return HTTPForbidden()(environ, start_response)
                                     username = user.username
                                 except:
                                     log.error(traceback.format_exc())
                 def __make_app(self, repo_name, repo_path):
                     """
                     Make an wsgi application using dulserver
                     :param repo_name: name of the repository
                     :param repo_path: full path to the repository
                     """

rhodecode/lib/middleware/simplehg.py

0 +2 -3

                 def __inject_extras(self, repo_path, baseui, extras={}):
                     """
                     Injects some extra params into baseui instance
                     also overwrites global settings with those takes from local hgrc file
                     :param baseui: baseui instance
                     :param extras: dict with extra params to put into baseui
                     """
                         for section in ui_sections:
                             for k, v in repoui.configitems(section):
                                 baseui.setconfig(section, k, v)

rhodecode/lib/rcmail/exceptions.py

0 +1 -1

                 as recipients or sender address.
                 """
             class BadHeaders(RuntimeError):
                 """
                 Raised if message contains newlines in headers.
                 """

rhodecode/lib/rcmail/message.py

0 +21 -23

                 :param disposition: content-disposition (if any)
                 """
                 def __init__(self,
                              filename=None,
                              content_type=None,
                              data=None,
                              disposition=None):
                     self.filename = filename
                     self.content_type = content_type
                 :param attachments: list of Attachment instances
                 """
                 def __init__(self,
                              subject=None,
                              recipients=None,
                              body=None,
                              html=None,
                              sender=None,
                              cc=None,
                              bcc=None,
                     """
                     Returns raw email.Message instance.Validates message first.
                     """
                     self.validate()
                     return self.get_response().to_message()
                     Creates a Lamson MailResponse instance
                     """
                     response = MailResponse(Subject=self.subject,
                                             To=self.recipients,
                                             From=self.sender,
                                             Body=self.body,
                     for attachment in self.attachments:
                         response.attach(attachment.filename,
                                         attachment.content_type,
                                         attachment.data,
                                         attachment.disposition)
                     response.update(self.extra_headers)
                     return response
                 def is_bad_headers(self):
                     """
                     Checks for bad headers i.e. newlines in subject, sender or recipients.
                     """
                     headers = [self.subject, self.sender]
                     headers += list(self.send_to)
                     headers += self.extra_headers.values()
                             if c in val:
                                 return True
                     return False
                 def validate(self):
                     """
                     Checks if message is valid and raises appropriate exception.
                 def add_recipient(self, recipient):
                     """
                     Adds another recipient to the message.
                     :param recipient: email address of recipient.
                     """
                     self.recipients.append(recipient)
                 def add_cc(self, recipient):
                     """
                     Adds an email address to the CC list.
                     :param recipient: email address of recipient.
                     """
                 def add_bcc(self, recipient):
                     """
                     Adds an email address to the BCC list.
                     :param recipient: email address of recipient.
                     """
                     """
                     self.attachments.append(attachment)

rhodecode/lib/rcmail/response.py

0 +3 -3

             def normalize_header(header):
                 return string.capwords(header.lower(), '-')
             class EncodingError(Exception):
                 """Thrown when there is an encoding error."""
                 pass
                     self.headers = dict(items)
                     self.parts = []
                     self.body = None
                     self.content_encoding = {'Content-Type': (None, {}),
                                              'Content-Disposition': (None, {}),
                                              'Content-Transfer-Encoding': (None, {})}
             def to_message(mail):
                 """
                 Given a MailBase message, this will construct a MIMEPart
                 that is canonicalized for use with the Python email API.
                 """
                 ctype, params = mail.content_encoding['Content-Type']

rhodecode/lib/utils.py

0 +3 -3

             def is_valid_repos_group(repos_group_name, base_path):
                 """
                 Returns True if given path is a repos group False otherwise
                 :param repo_name:
                 :param base_path:
                 """
             def create_test_index(repo_location, config, full_index):
                 """
                 Makes default test index
                 :param config: test config
                 :param full_index:
                 """
                     path_to_ini_file = os.path.realpath(conf)
                     conf = paste.deploy.appconfig('config:' + path_to_ini_file)
-                    pylonsconfig.init_app(conf.global_conf, conf.local_conf)
  No newline at end of file
+                    pylonsconfig.init_app(conf.global_conf, conf.local_conf)

rhodecode/model/db.py

0 +6 -7

                 def get_dict(self, serialized=False):
                     """
                     return dict with keys and values corresponding
                     to this model data
                     """
                     d = {}
                     # also use __json__() if present to get additional fields
                     if hasattr(self, '__json__'):
                         for k, val in self.__json__().iteritems():
                             d[k] = val
                     return d
                 def get_appstruct(self):
                     Returns Invalidation object if this given key should be invalidated
                     None otherwise. `cache_active = False` means that this cache
                     state is not valid and needs to be invalidated
                     :param key:
                     """
                     return cls.query()\
                 def set_invalidate(cls, key):
                     """
                     Mark this Cache key for invalidation
                     :param key:
                     """
                 def set_valid(cls, key):
                     """
                     Mark this cache key as active and currently cached
                     :param key:
                     """
                     inv_obj = CacheInvalidation.query()\
                     """
                     Returns user associated with this changesetComment. ie those
                     who actually commented
                     :param cls:
                     :param revision:
                     """
                 repository_id = Column('repository_id', String(250), primary_key=True)
                 repository_path = Column('repository_path', Text)
                 version = Column('version', Integer)

rhodecode/model/forms.py

0 +1 -1

                                             )
                 remember = StringBoolean(if_missing=False)
                 chained_validators = [ValidAuth]
             def UserForm(edit=False, old_data={}):

rhodecode/model/notification.py

0 +2 -4

                         notification
                     :param subject:
                     :param body:
                     :param recipients: list of int, str or User objects, when None
                         is given send to all admins
                     :param type_: type of notification
                     :param with_email: send email with this notification
                 def get_email_tmpl(self, type_, **kwargs):
                     """
                     return generated template for email based on given type
                     :param type_:
                     """
                     _kwargs.update(kwargs)
                     log.debug('rendering tmpl %s with kwargs %s' % (base, _kwargs))
                     return email_template.render(**_kwargs)

rhodecode/model/repo.py

0 +4 -5

                 def _get_defaults(self, repo_name):
                     """
                     Get's information about repository, and returns a dict for
                     usage in forms
                     :param repo_name:
                     """
                 def create_fork(self, form_data, cur_user):
                     """
                     Simple wrapper into executing celery task for fork creation
                     :param form_data:
                     :param cur_user:
                     """
                 def delete_stats(self, repo_name):
                     """
                     removes stats for given repo
                     :param repo_name:
                     """
                     try:
                                                       % (datetime.today()\
                                                          .strftime('%Y%m%d_%H%M%S_%f'),
                                                         repo.repo_name)))

rhodecode/model/repo_permission.py

0 +2 -2

                             .filter(UsersGroupRepoToPerm.repository == repository) \
                             .scalar()
                 def update_users_group_permission(self, repository, users_group,
                                                   permission):
                     permission = Permission.get_by_key(permission)
                     current = self.get_users_group_permission(repository, users_group)
                         self.update_users_group_permission(repository, user_group,
                                                            permission)
                     else:
-                        self.delete_users_group_permission(repository, user_group)
  No newline at end of file
+                        self.delete_users_group_permission(repository, user_group)

rhodecode/model/repos_group.py

0 +3 -3

                 def __rename_group(self, old, new):
                     """
                     Renames a group on filesystem
                     :param group_name:
                     """
                 def __delete_group(self, group):
                     """
                     Deletes a group from a filesystem
                     :param group: instance of group from database
                     """
                     paths = group.full_path.split(RepoGroup.url_sep())
                         self.__rename_group(old_path, new_path)
                         # we need to get all repositories from this new group and
                         # rename them accordingly to new group path
                         for r in repos_group.repositories:
                             r.repo_name = r.get_new_name(r.just_name)

rhodecode/model/user.py

0 +6 -6

                                      active=True, admin=False, ldap_dn=None):
                     """
                     Creates a new instance if not found, or updates current one
                     :param username:
                     :param password:
                     :param email:
                 def create_for_container_auth(self, username, attrs):
                     """
                     Creates the given user if it's not already in the database
                     :param username:
                     :param attrs:
                     """
                     """
                     Checks if user is in database, if not creates this user marked
                     as ldap user
                     :param username:
                     :param password:
                     :param user_dn:
                 def delete(self, user):
                     user = self.__get_user(user)
                     try:
                         if user.username == 'default':
                             raise DefaultUserException(
                     if not isinstance(perm, Permission):
                         raise Exception('perm needs to be an instance of Permission class '
                                         'got %s instead' % type(perm))
                     user = self.__get_user(user)
                     obj = UserToPerm.query().filter(UserToPerm.user == user)\
                             .filter(UserToPerm.permission == perm).scalar()
                     if obj:

rhodecode/model/users_group.py

0 +4 -6

                 def delete(self, users_group):
                     try:
                         users_group = self.__get_users_group(users_group)
                         # check if this group is not assigned to repo
                         assigned_groups = UsersGroupRepoToPerm.query()\
                             .filter(UsersGroupRepoToPerm.users_group == users_group).all()
                         if assigned_groups:
                             raise UsersGroupsAssignedException('RepoGroup assigned to %s' %
                                                                assigned_groups)
                         self.sa.delete(users_group)
                     except:
                         log.error(traceback.format_exc())
                 def revoke_perm(self, users_group, perm):
                     if not isinstance(perm, Permission):
                         raise Exception('perm needs to be an instance of Permission class')
                     users_group = self.__get_users_group(users_group)
                     obj = UsersGroupToPerm.query()\
                         .filter(UsersGroupToPerm.users_group == users_group)\
                         .filter(UsersGroupToPerm.permission == perm).one()
                     self.sa.delete(obj)

rhodecode/tests/__init__.py

0 +1 -2

             ##RUNNING DESIRED TESTS
             # nosetests -x rhodecode.tests.functional.test_admin_settings:TestSettingsController.test_my_account
             # nosetests --pdb --pdb-failures
             environ = {}
             #SOME GLOBALS FOR TESTS
                 def checkSessionFlash(self, response, msg):
                     self.assertTrue('flash' in response.session)
                     self.assertTrue(msg in response.session['flash'][0][1])

rhodecode/tests/functional/test_admin_ldap_settings.py

0 +6 -6

                     self.log_user()
                     if skip_ldap_test:
                         raise SkipTest('skipping due to missing ldap lib')
                     test_url = url(controller='admin/ldap_settings',
                                    action='ldap_settings')
                     self.log_user()
                     if skip_ldap_test:
                         raise SkipTest('skipping due to missing ldap lib')
                     test_url = url(controller='admin/ldap_settings',
                                    action='ldap_settings')
                                 'ldap_attr_firstname':'',
                                 'ldap_attr_lastname':'',
                                 'ldap_attr_email':'' })
                     self.assertTrue("""<span class="error-message">The LDAP Login"""
                                     """ attribute of the CN must be specified""" in
                                     response.body)
                     self.assertTrue("""<span class="error-message">Please """
                                     """enter a number</span>""" in response.body)

rhodecode/tests/functional/test_admin_users.py

0 +4 -4

                     lastname = 'lastname'
                     email = 'mail@mail.com'
                     response = self.app.post(url('users'),
                                              {'username':username,
                                                'password':password,
                                                'password_confirmation':password_confirmation,
                                                'email':email})
                     self.assertTrue('''created user %s''' % (username) in
                                     response.session['flash'][0])
                     new_user = self.Session.query(User).\
                         .filter(User.username == username).one()
                     response = self.app.delete(url('user', id=new_user.user_id))
                     self.assertTrue("""successfully deleted user""" in
                                     response.session['flash'][0])
                 def test_delete_browser_fakeout(self):
                     response = self.app.post(url('user', id=1),
                                              params=dict(_method='delete'))
                 def test_show(self):

rhodecode/tests/functional/test_admin_users_groups.py

0 0 -4

@@ -85,7 +85,3 b' class TestAdminUsersGroupsController(Tes'
85		85
86	def test_revoke_members(self):	86	def test_revoke_members(self):
87	pass	87	pass
88
89
90
91

rhodecode/tests/functional/test_branches.py

0 0 -6

@@ -9,9 +9,3 b' class TestBranchesController(TestControl'
9	response.mustcontain("""<a href="/%s/files/27cd5cce30c96924232dffcd24178a07ffeb5dfc/">default</a>""" % HG_REPO)	9	response.mustcontain("""<a href="/%s/files/27cd5cce30c96924232dffcd24178a07ffeb5dfc/">default</a>""" % HG_REPO)
10	response.mustcontain("""<a href="/%s/files/97e8b885c04894463c51898e14387d80c30ed1ee/">git</a>""" % HG_REPO)	10	response.mustcontain("""<a href="/%s/files/97e8b885c04894463c51898e14387d80c30ed1ee/">git</a>""" % HG_REPO)
11	response.mustcontain("""<a href="/%s/files/2e6a2bf9356ca56df08807f4ad86d480da72a8f4/">web</a>""" % HG_REPO)	11	response.mustcontain("""<a href="/%s/files/2e6a2bf9356ca56df08807f4ad86d480da72a8f4/">web</a>""" % HG_REPO)
12
13
14
15
16
17

rhodecode/tests/functional/test_changeset_comments.py

0 0 -4

@@ -137,7 +137,3 b' class TestChangeSetCommentrController(Te'
137	repo_name=HG_REPO, revision=rev))	137	repo_name=HG_REPO, revision=rev))
138	self.assertTrue('''<div class="comments-number">0 comment(s)'''	138	self.assertTrue('''<div class="comments-number">0 comment(s)'''
139	''' (0 inline)</div>''' in response.body)	139	''' (0 inline)</div>''' in response.body)
140
141
142
143

rhodecode/tests/functional/test_files.py

0 +1 -4

                 def test_ajaxed_files_list(self):
                     self.log_user()
                     rev = '27cd5cce30c96924232dffcd24178a07ffeb5dfc'
                     response = self.app.get(url('files_nodelist_home',repo_name=HG_REPO,
                                                 f_path='/',
                                                 revision=rev),
                                             extra_environ={'HTTP_X_PARTIAL_XHR':'1'},
                                             )
                     self.assertTrue("vcs/web/simplevcs/views/repository.py" in response.body)

rhodecode/tests/functional/test_summary.py

0 +2 -2

                     self.log_user()
                     ID = Repository.get_by_repo_name(HG_REPO).repo_id
                     response = self.app.get(url(controller='summary',
                                                 action='index',
                                                 repo_name=HG_REPO))
                     #repo type
                     self.log_user()
                     ID = Repository.get_by_repo_name(HG_REPO).repo_id
                     response = self.app.get(url(controller='summary',
                                                 action='index',
                                                 repo_name='_%s' % ID))
                     #repo type

rhodecode/tests/functional/test_tags.py

0 0 -1

                     response.mustcontain("""<a href="/%s/files/17544fbfcd33ffb439e2b728b5d526b1ef30bfcf/">0.1.3</a>""" % HG_REPO)
                     response.mustcontain("""<a href="/%s/files/a7e60bff65d57ac3a1a1ce3b12a70f8a9e8a7720/">0.1.2</a>""" % HG_REPO)
                     response.mustcontain("""<a href="/%s/files/eb3a60fc964309c1a318b8dfe26aa2d1586c85ae/">0.1.1</a>""" % HG_REPO)

rhodecode/tests/rhodecode_crawler.py

0 +1 -1

                 Test for crawling a project for memory usage
                 This should be runned just as regular script together
                 with a watch script that will show memory usage.
                 watch -n1 ./rhodecode/tests/mem_watch
                 :created_on: Apr 21, 2010

rhodecode/tests/test_libs.py

0 +1 -3

                 Package for testing various lib/helper functions in rhodecode
                 :created_on: Jun 9, 2011
                 :copyright: (C) 2009-2011 Marcin Kuzminski <marcin@python-works.com>
                 :license: GPLv3, see COPYING for more details.
                     s = ['2one_more22', 'D', 'MARCIN', 'first', 'lukaszb',
                          'maRCiN', 'marcink', 'one']
                     self.assertEqual(s, extract_mentioned_users(sample))

rhodecode/tests/test_models.py

0 +3 -9

                 def __init__(self, methodName='runTest'):
                     Session.remove()
                     super(TestUser, self).__init__(methodName=methodName)
                 def test_create_and_remove(self):
                     usr = UserModel().create_or_update(username=u'test_user', password=u'qweqwe',
                                                  email=u'u232@rhodecode.org',
                     self.u1 = UserModel().create_or_update(username=u'u1',
                                                     password=u'qweqwe',
                                                     email=u'u1@rhodecode.org',
                                                     name=u'u1', lastname=u'u1')
                 def tearDown(self):
                     perm = Permission.query().all()
                     for p in perm:
                         UserModel().revoke_perm(self.u1, p)
                     UserModel().delete(self.u1)
                     Session.commit()
                     UserModel().revoke_perm(self.u1, perm)
                     Session.commit()
                     self.assertEqual(UserModel().has_perm(self.u1, perm),False)

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

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