kallithea Changeset - e1ab82613133

Changeset - e1ab82613133

Parent rev.

Child rev.

[Not reviewed]

default

0 33 1

Alessandro Molina - 9 years ago 2017-01-29 21:08:49
alessandro.molina@axant.it

backend: replace Pylons with TurboGears2

Replace the no-longer-supported Pylons application framework by TurboGears2
which is largely compatible/similar to Pylons.
Some interesting history is described at:
https://en.wikipedia.org/wiki/TurboGears

Changes by Dominik Ruf:
- fix sql config in test.ini

Changes by Thomas De Schampheleire:
- set-up of test suite
- tests: 'fix' repo archival test failure
Between Pylons and TurboGears2, there seems to be a small difference in the
headers sent for repository archive files, related to character encoding.
It is assumed that this difference is not important, and that the test
should just align with reality.
- remove need to import helpers/app_globals in lib
TurboGears2 by default expects helpers and app_globals to be available
in lib. For this reason kallithea/lib/__init__.py was originally changed
to include those files. However, this triggered several types of
circular import problems. If module A imported something from lib (e.g.
lib.annotate), and lib.helpers imported (possibly indirectly) module A,
then there was a circular import. Fix this by overruling the relevant
method of tg AppConfig, which is also hinted in the TurboGears2 code.
Hereby, the include of something from lib does not automatically import
helpers, greatly reducing the chances of circular import problems.
- make sure HTTP error '400' uses the custom error pages
TurboGears2 does not by default handle HTTP status code
'400 (Bad Request)' via the custom error page handling, causing a
standard non-styled error page.
- disable transaction manager
Kallithea currently handles its own transactions and does not need the
TurboGears2 transaction manager. However, TurboGears2 tries to enable it
by default and fails, throwing an error during application initialization.
The error itself seemed to be harmless for normal application functioning,
but was nevertheless confusing.
- add backlash as required dependency: backlash is meant as the WebError
replacement in TurboGears2 (originally WebError is part of Pylons). When
debug==true, it provides an interactive debugger in the browser. When
debug==false, backlash is necessary to show backtraces on the console.
- misc fixes

34 files changed with 284 insertions and 309 deletions:

dev_requirements.txt

development.ini

kallithea/__init__.py

kallithea/config/app_cfg.py

103

113

kallithea/config/environment.py

kallithea/config/middleware.py

kallithea/config/routing.py

kallithea/controllers/admin/repo_groups.py

kallithea/controllers/admin/user_groups.py

kallithea/controllers/admin/users.py

kallithea/controllers/api/__init__.py

kallithea/controllers/error.py

kallithea/controllers/root.py

kallithea/lib/app_globals.py

kallithea/lib/base.py

kallithea/lib/paster_commands/common.py

kallithea/lib/paster_commands/make_index.py

kallithea/lib/paster_commands/make_rcextensions.py

kallithea/lib/paster_commands/template.ini.mako

kallithea/lib/utils.py

kallithea/model/notification.py

kallithea/model/repo.py

kallithea/tests/base.py

kallithea/tests/conftest.py

kallithea/tests/functional/test_admin_notifications.py

kallithea/tests/functional/test_admin_permissions.py

kallithea/tests/functional/test_admin_users.py

kallithea/tests/functional/test_login.py

kallithea/tests/functional/test_my_account.py

kallithea/tests/functional/test_pullrequests.py

kallithea/tests/models/test_notifications.py

kallithea/tests/other/test_libs.py

kallithea/tests/test.ini

setup.py

0 comments (0 inline, 0 general)

dev_requirements.txt

➞

Show inline comments

@@ @@ -3,6 +3,7 @@ waitress >= 0.8.8, < 1.0 @@
 pytest ~= 3.0
 pytest-runner
 pytest-sugar>=0.7.0
 pytest-catchlog
 mock
 sphinx
 webtest < 3

development.ini

➞

Show inline comments

@@ @@ -509,13 +509,13 @@ script_location = kallithea:alembic @@
 ################################
 ### LOGGING CONFIGURATION   ####
 ################################
 [loggers]
 keys = root, routes, kallithea, sqlalchemy, gearbox, beaker, templates, whoosh_indexer
+keys = root, routes, kallithea, sqlalchemy, tg, gearbox, beaker, templates, whoosh_indexer
 [handlers]
 keys = console, console_sql
 [formatters]
 keys = generic, color_formatter, color_formatter_sql
@@ @@ -550,12 +550,18 @@ propagate = 1 @@
 [logger_kallithea]
 level = DEBUG
 handlers =
 qualname = kallithea
 propagate = 1
 [logger_tg]
 level = DEBUG
 handlers =
 qualname = tg
 propagate = 1
 [logger_gearbox]
 level = DEBUG
 handlers =
 qualname = gearbox
 propagate = 1

kallithea/__init__.py

➞

Show inline comments

@@ @@ -27,16 +27,12 @@ Original author and date, and relevant c @@
 :license: GPLv3, see LICENSE.md for more details.
 """
 import sys
 import platform
 # temporary aliasing to allow early introduction of imports like 'from tg import request'
 import pylons
 sys.modules['tg'] = pylons
 VERSION = (0, 3, 99)
 BACKENDS = {
     'hg': 'Mercurial repository',
     'git': 'Git repository',
+}

kallithea/config/app_cfg.py

➞

Show inline comments

@@ @@ -8,178 +8,168 @@ @@
 # 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/>.
 """
 Global configuration file for TurboGears2 specific settings in Kallithea.
 import os
 import kallithea
 This file complements the .ini file.
 """
 import platform
 import pylons
 import mako.lookup
 import formencode
 import os, sys
 import kallithea.lib.app_globals as app_globals
 from kallithea.config.routing import make_map
 import tg
 from tg import hooks
 from tg.configuration import AppConfig
 from tg.support.converters import asbool
 from kallithea.lib import helpers
 from kallithea.lib.middleware.https_fixup import HttpsFixup
 from kallithea.lib.middleware.simplegit import SimpleGit
 from kallithea.lib.middleware.simplehg import SimpleHg
 from kallithea.config.routing import make_map
 from kallithea.lib.auth import set_available_permissions
 from kallithea.lib.utils import repo2db_mapper, make_ui, set_app_settings, \
     load_rcextensions, check_git_version, set_vcs_config, set_indexer_config
 from kallithea.lib.utils2 import engine_from_config, str2bool
 from kallithea.model.base import init_model
 from kallithea.lib.db_manage import DbManage
 from kallithea.lib.utils import load_rcextensions, make_ui, set_app_settings, set_vcs_config, \
     set_indexer_config, check_git_version, repo2db_mapper
 from kallithea.lib.utils2 import str2bool
 from kallithea.model.scm import ScmModel
 from routes.middleware import RoutesMiddleware
 from paste.cascade import Cascade
 from paste.registry import RegistryManager
 from paste.urlparser import StaticURLParser
 from paste.deploy.converters import asbool
 import formencode
 import kallithea
 class KallitheaAppConfig(AppConfig):
     # Note: AppConfig has a misleading name, as it's not the application
     # configuration, but the application configurator. The AppConfig values are
     # used as a template to create the actual configuration, which might
     # overwrite or extend the one provided by the configurator template.
     # To make it clear, AppConfig creates the config and sets into it the same
     # values that AppConfig itself has. Then the values from the config file and
     # gearbox options are loaded and merged into the configuration. Then an
     # after_init_config(conf) method of AppConfig is called for any change that
     # might depend on options provided by configuration files.
     def __init__(self):
         super(KallitheaAppConfig, self).__init__()
         self['package'] = kallithea
         self['prefer_toscawidgets2'] = False
         self['use_toscawidgets'] = False
         self['renderers'] = []
         # Enable json in expose
         self['renderers'].append('json')
 from pylons.middleware import ErrorHandler, StatusCodeRedirect
 from pylons.wsgiapp import PylonsApp
         # Configure template rendering
         self['renderers'].append('mako')
         self['default_renderer'] = 'mako'
         self['use_dotted_templatenames'] = False
         # Configure Sessions, store data as JSON to avoid pickle security issues
         self['session.enabled'] = True
         self['session.data_serializer'] = 'json'
         # Configure the base SQLALchemy Setup
         self['use_sqlalchemy'] = True
         self['model'] = kallithea.model.base
         self['DBSession'] = kallithea.model.meta.Session
         # Configure App without an authentication backend.
         self['auth_backend'] = None
 from kallithea.lib.middleware.simplehg import SimpleHg
 from kallithea.lib.middleware.simplegit import SimpleGit
 from kallithea.lib.middleware.https_fixup import HttpsFixup
 from kallithea.lib.middleware.sessionmiddleware import SecureSessionMiddleware
 from kallithea.lib.middleware.wrapper import RequestWrapper
         # Use custom error page for these errors. By default, Turbogears2 does not add
         # 400 in this list.
         # Explicitly listing all is considered more robust than appending to defaults,
         # in light of possible future framework changes.
         self['errorpage.status_codes'] = [400, 401, 403, 404]
 def setup_configuration(config, paths, app_conf, test_env, test_index):
         # Disable transaction manager -- currently Kallithea takes care of transactions itself
         self['tm.enabled'] = False
 base_config = KallitheaAppConfig()
 # TODO still needed as long as we use pylonslib
 sys.modules['pylons'] = tg
 def setup_configuration(app):
     config = app.config
     # store some globals into kallithea
     kallithea.CELERY_ON = str2bool(config['app_conf'].get('use_celery'))
     kallithea.CELERY_EAGER = str2bool(config['app_conf'].get('celery.always.eager'))
     kallithea.CONFIG = config
     config['routes.map'] = make_map(config)
     config['pylons.app_globals'] = app_globals.Globals(config)
     config['pylons.h'] = helpers
     kallithea.CONFIG = config
     # Provide routes mapper to the RoutedController
     root_controller = app.find_controller('root')
     root_controller.mapper = config['routes.map'] = make_map(config)
     load_rcextensions(root_path=config['here'])
     # Setup cache object as early as possible
     pylons.cache._push_object(config['pylons.app_globals'].cache)
     # Create the Mako TemplateLookup, with the default auto-escaping
     config['pylons.app_globals'].mako_lookup = mako.lookup.TemplateLookup(
         directories=paths['templates'],
         strict_undefined=True,
         module_directory=os.path.join(app_conf['cache_dir'], 'templates'),
         input_encoding='utf-8', default_filters=['escape'],
         imports=['from webhelpers.html import escape'])
     # sets the c attribute access when don't existing attribute are accessed
     config['pylons.strict_tmpl_context'] = True
     # FIXME move test setup code out of here
     test = os.path.split(config['__file__'])[-1] == 'test.ini'
     if test:
         if test_env is None:
             test_env = not int(os.environ.get('KALLITHEA_NO_TMP_PATH', 0))
         if test_index is None:
             test_index = not int(os.environ.get('KALLITHEA_WHOOSH_TEST_DISABLE', 0))
         test_env = not int(os.environ.get('KALLITHEA_NO_TMP_PATH', 0))
         test_index = not int(os.environ.get('KALLITHEA_WHOOSH_TEST_DISABLE', 0))
         if os.environ.get('TEST_DB'):
-            # swap config if we pass enviroment variable
+            # swap config if we pass environment variable
             config['sqlalchemy.url'] = os.environ.get('TEST_DB')
         from kallithea.tests.fixture import create_test_env, create_test_index
         from kallithea.tests.base import TESTS_TMP_PATH
         #set KALLITHEA_NO_TMP_PATH=1 to disable re-creating the database and
         #test repos
         if test_env:
             create_test_env(TESTS_TMP_PATH, config)
         #set KALLITHEA_WHOOSH_TEST_DISABLE=1 to disable whoosh index during tests
         if test_index:
             create_test_index(TESTS_TMP_PATH, config, True)
     # MULTIPLE DB configs
     # Setup the SQLAlchemy database engine
     sa_engine = engine_from_config(config, 'sqlalchemy.')
     init_model(sa_engine)
     set_available_permissions(config)
     repos_path = make_ui('db').configitems('paths')[0][1]
     config['base_path'] = repos_path
     set_app_settings(config)
     instance_id = kallithea.CONFIG.get('instance_id', '*')
     if instance_id == '*':
         instance_id = '%s-%s' % (platform.uname()[1], os.getpid())
         kallithea.CONFIG['instance_id'] = instance_id
     # CONFIGURATION OPTIONS HERE (note: all config options will override
     # any Pylons config options)
     # update kallithea.CONFIG with the meanwhile changed 'config'
     kallithea.CONFIG.update(config)
     # store config reference into our module to skip import magic of
     # pylons
     kallithea.CONFIG.update(config)
     # configure vcs and indexer libraries (they are supposed to be independent
     # as much as possible and thus avoid importing tg.config or
     # kallithea.CONFIG).
     set_vcs_config(kallithea.CONFIG)
     set_indexer_config(kallithea.CONFIG)
     #check git version
     check_git_version()
     if str2bool(config.get('initial_repo_scan', True)):
         repo2db_mapper(ScmModel().repo_scan(repos_path),
                        remove_obsolete=False, install_git_hooks=False)
     formencode.api.set_stdtranslation(languages=[config.get('lang')])
     return config
 def setup_application(config, global_conf, full_stack, static_files):
 hooks.register('configure_new_app', setup_configuration)
     # The Pylons WSGI app
     app = PylonsApp(config=config)
     # Routing/Session/Cache Middleware
     app = RoutesMiddleware(app, config['routes.map'], use_method_override=False)
     app = SecureSessionMiddleware(app, config)
     # CUSTOM MIDDLEWARE HERE (filtered by error handling middlewares)
     if asbool(config['pdebug']):
         from kallithea.lib.profiler import ProfilingMiddleware
         app = ProfilingMiddleware(app)
     if asbool(full_stack):
         from kallithea.lib.middleware.sentry import Sentry
         from kallithea.lib.middleware.appenlight import AppEnlight
         if AppEnlight and asbool(config['app_conf'].get('appenlight')):
             app = AppEnlight(app, config)
         elif Sentry:
             app = Sentry(app, config)
         # Handle Python exceptions
         app = ErrorHandler(app, global_conf, **config['pylons.errorware'])
 def setup_application(app):
     config = app.config
         # Display error documents for 401, 403, 404 status codes (and
         # 500 when debug is disabled)
         # Note: will buffer the output in memory!
         if asbool(config['debug']):
             app = StatusCodeRedirect(app)
         else:
             app = StatusCodeRedirect(app, [400, 401, 403, 404, 500])
         # we want our low level middleware to get to the request ASAP. We don't
         # need any pylons stack middleware in them - especially no StatusCodeRedirect buffering
         app = SimpleHg(app, config)
         app = SimpleGit(app, config)
     # we want our low level middleware to get to the request ASAP. We don't
     # need any stack middleware in them - especially no StatusCodeRedirect buffering
     app = SimpleHg(app, config)
     app = SimpleGit(app, config)
         # Enable https redirects based on HTTP_X_URL_SCHEME set by proxy
         if any(asbool(config.get(x)) for x in ['https_fixup', 'force_https', 'use_htsts']):
             app = HttpsFixup(app, config)
         app = RequestWrapper(app, config) # logging
     # Establish the Registry for this application
     app = RegistryManager(app) # thread / request-local module globals / variables
     # Enable https redirects based on HTTP_X_URL_SCHEME set by proxy
     if any(asbool(config.get(x)) for x in ['https_fixup', 'force_https', 'use_htsts']):
         app = HttpsFixup(app, config)
     return app
     if asbool(static_files):
         # Serve static files
         static_app = StaticURLParser(config['pylons.paths']['static_files'])
         app = Cascade([static_app, app])
     app.config = config
     return app
 hooks.register('before_config', setup_application)

kallithea/config/environment.py

➞

Show inline comments

@@ @@ -8,37 +8,14 @@ @@
 # 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/>.
 """
     Pylons environment configuration
 """
 """WSGI environment setup for Kallithea."""
 import os
 import kallithea
 import pylons
 from kallithea.config.app_cfg import setup_configuration
 from kallithea.config.app_cfg import base_config
 def load_environment(global_conf, app_conf,
                      test_env=None, test_index=None):
     """
     Configure the Pylons environment via the ``pylons.config``
     object
     """
     config = pylons.configuration.PylonsConfig()
 __all__ = ['load_environment']
     # Pylons paths
     root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
     paths = dict(
         root=root,
         controllers=os.path.join(root, 'controllers'),
         static_files=os.path.join(root, 'public'),
         templates=[os.path.join(root, 'templates')]
+    )
     # Initialize config with the basic options
     config.init_app(global_conf, app_conf, package='kallithea', paths=paths)
     return setup_configuration(config, paths, app_conf, test_env, test_index)
 # Use base_config to setup the environment loader function
 load_environment = base_config.make_load_environment()

kallithea/config/middleware.py

➞

Show inline comments

@@ @@ -8,36 +8,38 @@ @@
 # 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/>.
 """
     Pylons middleware initialization
 """
 """WSGI middleware initialization for the Kallithea application."""
-from kallithea.config.app_cfg import setup_application
+from kallithea.config.app_cfg import base_config
 from kallithea.config.environment import load_environment
 def make_app(global_conf, full_stack=True, static_files=True, **app_conf):
     """Create a Pylons WSGI application and return it
 __all__ = ['make_app']
 # Use base_config to setup the necessary PasteDeploy application factory.
 # make_base_app will wrap the TurboGears2 app with all the middleware it needs.
 make_base_app = base_config.setup_tg_wsgi_app(load_environment)
     ``global_conf``
         The inherited configuration for this application. Normally from
         the [DEFAULT] section of the Paste ini file.
 def make_app(global_conf, full_stack=True, **app_conf):
     """
     Set up Kallithea with the settings found in the PasteDeploy configuration
     file used.
     ``full_stack``
         Whether or not this application provides a full WSGI stack (by
         default, meaning it handles its own exceptions and errors).
         Disable full_stack when this application is "managed" by
         another WSGI middleware.
     :param global_conf: The global settings for Kallithea (those
         defined under the ``[DEFAULT]`` section).
     :type global_conf: dict
     :param full_stack: Should the whole TurboGears2 stack be set up?
     :type full_stack: str or bool
     :return: The Kallithea application with all the relevant middleware
         loaded.
     ``app_conf``
         The application's local configuration. Normally specified in
         the [app:<name>] section of the Paste ini file (where <name>
         defaults to main).
     This is the PasteDeploy factory for the Kallithea application.
     ``app_conf`` contains all the application-specific settings (those defined
     under ``[app:main]``.
     """
     # Configure the Pylons environment
     config = load_environment(global_conf, app_conf)
     return setup_application(config, global_conf, full_stack, static_files)
     app = make_base_app(global_conf, full_stack=full_stack, **app_conf)
     return app

kallithea/config/routing.py

➞

Show inline comments

@@ @@ -25,13 +25,13 @@ from routes import Mapper @@
 # prefix for non repository related links needs to be prefixed with `/`
 ADMIN_PREFIX = '/_admin'
 def make_map(config):
     """Create, configure and return the routes Mapper"""
-    rmap = Mapper(directory=config['pylons.paths']['controllers'],
     rmap = Mapper(directory=config['paths']['controllers'],
                   always_scan=config['debug'])
     rmap.minimization = False
     rmap.explicit = False
     from kallithea.lib.utils import (is_valid_repo, is_valid_repo_group,
                                      get_repo_by_id)
@@ @@ -43,13 +43,13 @@ def make_map(config): @@
         :param environ:
         :param match_dict:
         """
         repo_name = match_dict.get('repo_name')
         if match_dict.get('f_path'):
             #fix for multiple initial slashes that causes errors
+            # fix for multiple initial slashes that causes errors
             match_dict['f_path'] = match_dict['f_path'].lstrip('/')
         by_id_match = get_repo_by_id(repo_name)
         if by_id_match:
             repo_name = by_id_match
             match_dict['repo_name'] = repo_name
@@ @@ -87,17 +87,12 @@ def make_map(config): @@
         """
         return True
     def check_int(environ, match_dict):
         return match_dict.get('id').isdigit()
     # The ErrorController route (handles 404/500 error pages); it should
     # likely stay at the top, ensuring it can always be resolved
     rmap.connect('/error/{action}', controller='error')
     rmap.connect('/error/{action}/{id}', controller='error')
     #==========================================================================
     # CUSTOM ROUTES HERE
     #==========================================================================
     #MAIN PAGE
     rmap.connect('home', '/', controller='home', action='index')
@@ @@ -423,14 +418,14 @@ def make_map(config): @@
         m.connect('admin_home', '', action='index')
         m.connect('admin_add_repo', '/add_repo/{new_repo:[a-z0-9\. _-]*}',
                   action='add_repo')
     #==========================================================================
     # API V2
     #==========================================================================
     with rmap.submapper(path_prefix=ADMIN_PREFIX,
                         controller='api/api') as m:
     with rmap.submapper(path_prefix=ADMIN_PREFIX, controller='api/api',
                         action='_dispatch') as m:
         m.connect('api', '/api')
     #USER JOURNAL
     rmap.connect('journal', '%s/journal' % ADMIN_PREFIX,
                  controller='journal', action='index')
     rmap.connect('journal_rss', '%s/journal/rss' % ADMIN_PREFIX,

kallithea/controllers/admin/repo_groups.py

➞

Show inline comments

@@ @@ -29,13 +29,13 @@ import logging @@
 import traceback
 import formencode
 import itertools
 from formencode import htmlfill
 from tg import request, tmpl_context as c
+from tg import request, tmpl_context as c, app_globals
 from tg.i18n import ugettext as _, ungettext
 from webob.exc import HTTPFound, HTTPForbidden, HTTPNotFound, HTTPInternalServerError
 import kallithea
 from kallithea.config.routing import url
 from kallithea.lib import helpers as h
@@ @@ -109,13 +109,13 @@ class RepoGroupsController(BaseControlle @@
     def index(self, format='html'):
         _list = RepoGroup.query(sorted=True).all()
         group_iter = RepoGroupList(_list, perm_level='admin')
         repo_groups_data = []
         total_records = len(group_iter)
-        _tmpl_lookup = kallithea.CONFIG['pylons.app_globals'].mako_lookup
         _tmpl_lookup = app_globals.mako_lookup
         template = _tmpl_lookup.get_template('data_table/_dt_elements.html')
         repo_group_name = lambda repo_group_name, children_groups: (
             template.get_def("repo_group_name")
             .render(repo_group_name, children_groups, _=_, h=h, c=c)
+        )

kallithea/controllers/admin/user_groups.py

➞

Show inline comments

@@ @@ -27,13 +27,13 @@ Original author and date, and relevant c @@
 import logging
 import traceback
 import formencode
 from formencode import htmlfill
 from tg import request, tmpl_context as c, config
+from tg import request, tmpl_context as c, config, app_globals
 from tg.i18n import ugettext as _
 from webob.exc import HTTPFound
 from sqlalchemy.orm import joinedload
 from sqlalchemy.sql.expression import func
 from webob.exc import HTTPInternalServerError
@@ @@ -91,13 +91,13 @@ class UserGroupsController(BaseControlle @@
         _list = UserGroup.query() \
                         .order_by(func.lower(UserGroup.users_group_name)) \
                         .all()
         group_iter = UserGroupList(_list, perm_level='admin')
         user_groups_data = []
         total_records = len(group_iter)
-        _tmpl_lookup = kallithea.CONFIG['pylons.app_globals'].mako_lookup
         _tmpl_lookup = app_globals.mako_lookup
         template = _tmpl_lookup.get_template('data_table/_dt_elements.html')
         user_group_name = lambda user_group_id, user_group_name: (
             template.get_def("user_group_name")
             .render(user_group_id, user_group_name, _=_, h=h, c=c)
+        )

kallithea/controllers/admin/users.py

➞

Show inline comments

@@ @@ -27,13 +27,13 @@ Original author and date, and relevant c @@
 import logging
 import traceback
 import formencode
 from formencode import htmlfill
 from tg import request, tmpl_context as c, config
+from tg import request, tmpl_context as c, config, app_globals
 from tg.i18n import ugettext as _
 from sqlalchemy.sql.expression import func
 from webob.exc import HTTPFound, HTTPNotFound
 import kallithea
 from kallithea.config.routing import url
@@ @@ -70,13 +70,13 @@ class UsersController(BaseController): @@
                         .filter_by(is_default_user=False) \
                         .order_by(func.lower(User.username)) \
                         .all()
         users_data = []
         total_records = len(c.users_list)
-        _tmpl_lookup = kallithea.CONFIG['pylons.app_globals'].mako_lookup
         _tmpl_lookup = app_globals.mako_lookup
         template = _tmpl_lookup.get_template('data_table/_dt_elements.html')
         grav_tmpl = '<div class="gravatar">%s</div>'
         username = lambda user_id, username: (
                 template.get_def("user_name")

kallithea/controllers/api/__init__.py

➞

Show inline comments

@@ @@ -29,18 +29,15 @@ import inspect @@
 import logging
 import types
 import traceback
 import time
 import itertools
 from paste.response import replace_header
 from pylons.controllers import WSGIController
 from pylons.controllers.util import Response
 from tg import request
 from tg import Response, response, request, TGController
 from webob.exc import HTTPError
+from webob.exc import HTTPError, HTTPException, WSGIHTTPException
 from kallithea.model.db import User
 from kallithea.model import meta
 from kallithea.lib.compat import json
 from kallithea.lib.auth import AuthUser
 from kallithea.lib.base import _get_ip_addr as _get_ip, _get_access_path
@@ @@ -56,25 +53,26 @@ class JSONRPCError(BaseException): @@
         super(JSONRPCError, self).__init__()
     def __str__(self):
         return safe_str(self.message)
-class JSONRPCErrorResponse(Response, Exception):
+class JSONRPCErrorResponse(Response, HTTPException):
     """
     Generate a Response object with a JSON-RPC error body
     """
     def __init__(self, message=None, retid=None, code=None):
         HTTPException.__init__(self, message, self)
         Response.__init__(self,
-                          body=json.dumps(dict(id=retid, result=None, error=message)),
+                          json_body=dict(id=retid, result=None, error=message),
                           status=code,
                           content_type='application/json')
-class JSONRPCController(WSGIController):
+class JSONRPCController(TGController):
     """
      A WSGI-speaking JSON-RPC controller class
      See the specification:
      <http://json-rpc.org/wiki/specification>`.
@@ @@ -92,25 +90,21 @@ class JSONRPCController(WSGIController): @@
         """
         Return `self._rpc_args` to dispatched controller method
         chosen by __call__
         """
         return self._rpc_args
-    def __call__(self, environ, start_response):
+    def _dispatch(self, state, remainder=None):
         """
         Parse the request body as JSON, look up the method on the
         controller and if it exists, dispatch to it.
         """
         try:
             return self._handle_request(environ, start_response)
         except JSONRPCErrorResponse as e:
             return e
         finally:
             meta.Session.remove()
         # Since we are here we should respond as JSON
         response.content_type = 'application/json'
-    def _handle_request(self, environ, start_response):
+        environ = state.request.environ
         start = time.time()
         ip_addr = request.ip_addr = self._get_ip_addr(environ)
         self._req_id = None
         if 'CONTENT_LENGTH' not in environ:
             log.debug("No Content-Length")
             raise JSONRPCErrorResponse(retid=self._req_id,
@@ @@ -215,45 +209,32 @@ class JSONRPCController(WSGIController): @@
                     retid=self._req_id,
                     message='Unknown %s arg in JSON DATA' %
                             ', '.join('`%s`' % arg for arg in extra),
+                )
         self._rpc_args = {}
         self._rpc_args.update(self._request_params)
         self._rpc_args['action'] = self._req_method
         self._rpc_args['environ'] = environ
         self._rpc_args['start_response'] = start_response
         status = []
         headers = []
         exc_info = []
         def change_content(new_status, new_headers, new_exc_info=None):
             status.append(new_status)
             headers.extend(new_headers)
             exc_info.append(new_exc_info)
         output = WSGIController.__call__(self, environ, change_content)
         output = list(output) # expand iterator - just to ensure exact timing
         replace_header(headers, 'Content-Type', 'application/json')
         start_response(status[0], headers, exc_info[0])
         log.info('IP: %s Request to %s time: %.3fs' % (
             self._get_ip_addr(environ),
             safe_unicode(_get_access_path(environ)), time.time() - start)
+        )
         return output
     def _dispatch_call(self):
         state.set_action(self._rpc_call, [])
         state.set_params(self._rpc_args)
         return state
     def _rpc_call(self, action, environ, **rpc_args):
         """
-        Implement dispatch interface specified by WSGIController
+        Call the specified RPC Method
         """
         raw_response = ''
         try:
-            raw_response = self._inspect_call(self._func)
+            raw_response = getattr(self, action)(**rpc_args)
             if isinstance(raw_response, HTTPError):
                 self._error = str(raw_response)
         except JSONRPCError as e:
             self._error = safe_str(e)
         except Exception as e:
             log.error('Encountered unhandled exception: %s',

kallithea/controllers/error.py

➞

Show inline comments

@@ @@ -26,15 +26,14 @@ Original author and date, and relevant c @@
 """
 import os
 import cgi
 import logging
 from tg import tmpl_context as c, request, config
+from tg import tmpl_context as c, request, config, expose
 from tg.i18n import ugettext as _
 from pylons.middleware import media_path
 from kallithea.lib.base import BaseController, render
 log = logging.getLogger(__name__)
@@ @@ -49,14 +48,15 @@ class ErrorController(BaseController): @@
     """
     def _before(self, *args, **kwargs):
         # disable all base actions since we don't need them here
         pass
     def document(self):
         resp = request.environ.get('pylons.original_response')
     @expose('/errors/error_document.html')
     def document(self, *args, **kwargs):
         resp = request.environ.get('tg.original_response')
         c.site_name = config.get('title')
         log.debug('### %s ###', resp and resp.status or 'no response')
         e = request.environ
         c.serv_p = r'%(protocol)s://%(host)s/' % {
@@ @@ -67,13 +67,13 @@ class ErrorController(BaseController): @@
                                                          str(resp.status)))
             c.error_explanation = self.get_error_explanation(resp.status_int)
         else:
             c.error_message = _('No response')
             c.error_explanation = _('Unknown error')
-        return render('/errors/error_document.html')
+        return dict()
     def get_error_explanation(self, code):
         """ get the error explanations of int codes
             [400, 401, 403, 404, 500]"""
         try:
             code = int(code)

kallithea/controllers/root.py

➞

Show inline comments

@@ new file 100644 @@
 # -*- coding: utf-8 -*-
 # 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 tgext.routes import RoutedController
 from kallithea.lib.base import BaseController
 from kallithea.controllers.error import ErrorController
 # With TurboGears, the RootController is the controller from which all routing
 # starts from. It is 'magically' found based on the fact that a controller
 # 'foo' is expected to have a class name FooController, located in a file
 # foo.py, inside config['paths']['controllers']. The name 'root' for the root
 # controller is the default name. The dictionary config['paths'] determines the
 # directories where templates, static files and controllers are found. It is
 # set up in tg.AppConfig based on AppConfig['package'] ('kallithea') and the
 # respective defaults 'templates', 'public' and 'controllers'.
 # Inherit from RoutedController to allow Kallithea to use regex-based routing.
 class RootController(RoutedController, BaseController):
     # the following assignment hooks in error handling
     error = ErrorController()

kallithea/lib/app_globals.py

➞

Show inline comments

@@ @@ -22,25 +22,31 @@ This file was forked by the Kallithea pr @@
 Original author and date, and relevant copyright and licensing information is below:
 :created_on: Oct 06, 2010
 :author: marcink
 :copyright: (c) 2013 RhodeCode GmbH, and others.
 :license: GPLv3, see LICENSE.md for more details.
 """
 from beaker.cache import CacheManager
 from beaker.util import parse_cache_config_options
 import tg
 from tg import config
 class Globals(object):
     """
     Globals acts as a container for objects available throughout the
     life of the application
     """
-    def __init__(self, config):
     def __init__(self):
         """One instance of Globals is created during application
         initialization and is available during requests via the
         'app_globals' variable
         """
         self.cache = CacheManager(**parse_cache_config_options(config))
         self.available_permissions = None   # propagated after init_model
     @property
     def cache(self):
         return tg.cache
     @property
     def mako_lookup(self):
         return config['render_functions']['mako'].normal_loader

kallithea/lib/base.py

➞

Show inline comments

@@ @@ -38,15 +38,14 @@ import warnings @@
 import webob.exc
 import paste.httpexceptions
 import paste.auth.basic
 import paste.httpheaders
 from webhelpers.pylonslib import secure_form
 from tg import config, tmpl_context as c, request, response, session
 from pylons.controllers import WSGIController
 from pylons.templating import render_mako as render  # don't remove this import
 from tg import config, tmpl_context as c, request, response, session, render_template
 from tg import TGController
 from tg.i18n import ugettext as _
 from kallithea import __version__, BACKENDS
 from kallithea.config.routing import url
 from kallithea.lib.utils2 import str2bool, safe_unicode, AttributeDict, \
@@ @@ -63,12 +62,16 @@ from kallithea.model.db import PullReque @@
 from kallithea.model.notification import NotificationModel
 from kallithea.model.scm import ScmModel
 log = logging.getLogger(__name__)
 def render(template_path):
     return render_template({'url': url}, 'mako', template_path)
 def _filter_proxy(ip):
     """
     HEADERS can have multiple ips inside the left-most being the original
     client, and each successive proxy that passed the request adding the IP
     address where it received the request from.
@@ @@ -98,13 +101,13 @@ def _get_ip_addr(environ): @@
     ip = environ.get(def_key, '0.0.0.0')
     return _filter_proxy(ip)
 def _get_access_path(environ):
     path = environ.get('PATH_INFO')
-    org_req = environ.get('pylons.original_request')
+    org_req = environ.get('tg.original_request')
     if org_req:
         path = org_req.environ.get('PATH_INFO')
     return path
 def log_in_user(user, remember, is_external_auth):
@@ @@ -372,20 +375,17 @@ class BaseVCSController(object): @@
         finally:
             log = logging.getLogger('kallithea.' + self.__class__.__name__)
             log.debug('Request time: %.3fs', time.time() - start)
             meta.Session.remove()
-class BaseController(WSGIController):
+class BaseController(TGController):
     def _before(self, *args, **kwargs):
         pass
     def __before__(self):
         """
-        __before__ is called before controller methods and after __call__
+        _before is called before controller methods and after __call__
         """
         c.kallithea_version = __version__
         rc_config = Setting.get_app_settings()
         # Visual options
         c.visual = AttributeDict({})
@@ @@ -434,19 +434,12 @@ class BaseController(WSGIController): @@
         self.cut_off_limit = safe_int(config.get('cut_off_limit'))
         c.my_pr_count = PullRequest.query(reviewer_id=request.authuser.user_id, include_closed=False).count()
         self.scm_model = ScmModel()
         # __before__ in Pylons is called _before in TurboGears2. As preparation
         # to the migration to TurboGears2, all __before__ methods were already
         # renamed to _before.  We call them from here to keep the behavior.
         # This is a temporary call that will be removed in the real TurboGears2
         # migration commit.
         self._before()
     @staticmethod
     def _determine_auth_user(api_key, bearer_token, session_authuser):
         """
         Create an `AuthUser` object given the API key/bearer token
         (if any) and the value of the authuser session cookie.
         """
@@ @@ -527,18 +520,13 @@ class BaseController(WSGIController): @@
         # than POST/PUT, but double-check since other Kallithea code relies on
         # this assumption.
         if request.method not in ['POST', 'PUT'] and request.POST:
             log.error('%r request with payload parameters; WebOb should have stopped this', request.method)
             raise webob.exc.HTTPBadRequest()
     def __call__(self, environ, start_response):
         """Invoke the Controller"""
         # WSGIController.__call__ dispatches to the Controller method
         # the request is routed to. This routing information is
         # available in environ['pylons.routes_dict']
     def __call__(self, environ, context):
         try:
             request.ip_addr = _get_ip_addr(environ)
             # make sure that we update permissions each time we call controller
             self._basic_security_checks()
@@ @@ -561,17 +549,15 @@ class BaseController(WSGIController): @@
+            )
             log.info('IP: %s User: %s accessed %s',
                 request.ip_addr, request.authuser,
                 safe_unicode(_get_access_path(environ)),
+            )
-            return WSGIController.__call__(self, environ, start_response)
+            return super(BaseController, self).__call__(environ, context)
         except webob.exc.HTTPException as e:
             return e(environ, start_response)
         finally:
             meta.Session.remove()
             return e
 class BaseRepoController(BaseController):
     """
     Base class for controllers responsible for loading all needed data for
     repository loaded items are

kallithea/lib/paster_commands/common.py

➞

Show inline comments

@@ @@ -79,18 +79,18 @@ class BasePasterCommand(gearbox.command. @@
         return parser
     def _bootstrap_config(self, config_file):
         """
         Read the config file and initialize logging and the application.
         """
-        from tg import config as pylonsconfig
+        from kallithea.config.middleware import make_app
         path_to_ini_file = os.path.realpath(config_file)
         conf = paste.deploy.appconfig('config:' + path_to_ini_file)
         logging.config.fileConfig(path_to_ini_file)
-        pylonsconfig.init_app(conf.global_conf, conf.local_conf)
+        make_app(conf.global_conf, **conf.local_conf)
     def _init_session(self):
         """
         Initialize SqlAlchemy Session from global config.
         """

kallithea/lib/paster_commands/make_index.py

➞

Show inline comments

@@ @@ -37,13 +37,13 @@ from kallithea.lib.utils import load_rce @@
 class Command(BasePasterCommand):
     "Kallithea: Create or update full text search index"
     def take_action(self, args):
-        from pylons import config
+        from tg import config
         index_location = config['index_dir']
         load_rcextensions(config['here'])
         repo_location = args.repo_location \
             if args.repo_location else RepoModel().repos_path
         repo_list = map(strip, args.repo_list.split(',')) \

kallithea/lib/paster_commands/make_rcextensions.py

➞

Show inline comments

@@ @@ -41,13 +41,13 @@ class Command(BasePasterCommand): @@
     The file contains instructions on how it can be customized.
     """
     takes_config_file = False
     def take_action(self, args):
-        from pylons import config
+        from tg import config
         here = config['here']
         content = pkg_resources.resource_string(
             'kallithea', os.path.join('config', 'rcextensions', '__init__.py')
+        )
         ext_file = os.path.join(here, 'rcextensions', '__init__.py')

kallithea/lib/paster_commands/template.ini.mako

➞

Show inline comments

@@ @@ -513,13 +513,13 @@ script_location = kallithea:alembic @@
 <%text>################################</%text>
 <%text>### LOGGING CONFIGURATION   ####</%text>
 <%text>################################</%text>
 [loggers]
 keys = root, routes, kallithea, sqlalchemy, gearbox, beaker, templates, whoosh_indexer
+keys = root, routes, kallithea, sqlalchemy, tg, gearbox, beaker, templates, whoosh_indexer
 [handlers]
 keys = console, console_sql
 [formatters]
 keys = generic, color_formatter, color_formatter_sql
@@ @@ -554,12 +554,18 @@ propagate = 1 @@
 [logger_kallithea]
 level = DEBUG
 handlers =
 qualname = kallithea
 propagate = 1
 [logger_tg]
 level = DEBUG
 handlers =
 qualname = tg
 propagate = 1
 [logger_gearbox]
 level = DEBUG
 handlers =
 qualname = gearbox
 propagate = 1

kallithea/lib/utils.py

➞

Show inline comments

@@ @@ -29,12 +29,13 @@ import os @@
 import re
 import logging
 import datetime
 import traceback
 import beaker
 from tg import request, response
 from webhelpers.text import collapse, remove_formatting, strip_tags
 from beaker.cache import _cache_decorate
 from kallithea.lib.vcs.utils.hgcompat import ui, config
 from kallithea.lib.vcs.utils.helpers import get_scm
 from kallithea.lib.vcs.exceptions import VCSError

kallithea/model/notification.py

➞

Show inline comments

@@ @@ -26,13 +26,13 @@ Original author and date, and relevant c @@
 :license: GPLv3, see LICENSE.md for more details.
 """
 import logging
 import traceback
 from tg import tmpl_context as c
+from tg import tmpl_context as c, app_globals
 from tg.i18n import ugettext as _
 from sqlalchemy.orm import joinedload, subqueryload
 import kallithea
 from kallithea.lib import helpers as h
 from kallithea.lib.utils2 import safe_unicode
@@ @@ -271,14 +271,14 @@ class EmailNotificationModel(object): @@
     TYPE_PULL_REQUEST = Notification.TYPE_PULL_REQUEST
     TYPE_PULL_REQUEST_COMMENT = Notification.TYPE_PULL_REQUEST_COMMENT
     TYPE_DEFAULT = 'default'
     def __init__(self):
         super(EmailNotificationModel, self).__init__()
         self._template_root = kallithea.CONFIG['pylons.paths']['templates'][0]
         self._tmpl_lookup = kallithea.CONFIG['pylons.app_globals'].mako_lookup
         self._template_root = kallithea.CONFIG['paths']['templates'][0]
         self._tmpl_lookup = app_globals.mako_lookup
         self.email_types = {
             self.TYPE_CHANGESET_COMMENT: 'changeset_comment',
             self.TYPE_PASSWORD_RESET: 'password_reset',
             self.TYPE_REGISTRATION: 'registration',
             self.TYPE_DEFAULT: 'default',
             self.TYPE_PULL_REQUEST: 'pull_request',

kallithea/model/repo.py

➞

Show inline comments

@@ @@ -150,16 +150,16 @@ class RepoModel(object): @@
                 'grmembers': len(gr.members),
             } for gr in user_groups]
     @classmethod
     def _render_datatable(cls, tmpl, *args, **kwargs):
         import kallithea
         from tg import tmpl_context as c, request
+        from tg import tmpl_context as c, request, app_globals
         from tg.i18n import ugettext as _
-        _tmpl_lookup = kallithea.CONFIG['pylons.app_globals'].mako_lookup
         _tmpl_lookup = app_globals.mako_lookup
         template = _tmpl_lookup.get_template('data_table/_dt_elements.html')
         tmpl = template.get_def(tmpl)
         kwargs.update(dict(_=_, h=h, c=c, request=request))
         return tmpl.render(*args, **kwargs)

kallithea/tests/base.py

➞

Show inline comments

@@ @@ -18,20 +18,15 @@ import os @@
 import pytest
 import re
 import tempfile
 import time
 from tg import config
 import pylons
 from pylons import url
 from pylons.i18n.translation import _get_translator
 from pylons.util import ContextObj
 from routes.util import URLGenerator
 from webtest import TestApp
 from kallithea import is_windows
+from kallithea import is_windows, model
 from kallithea.model.db import Notification, User, UserNotification
 from kallithea.model.meta import Session
 from kallithea.lib.utils2 import safe_str
 os.environ['TZ'] = 'UTC'
 if not is_windows:
@@ @@ -39,12 +34,16 @@ if not is_windows: @@
 log = logging.getLogger(__name__)
 skipif = pytest.mark.skipif
 parametrize = pytest.mark.parametrize
 # Hack: These module global values MUST be set to actual values before running any tests. This is currently done by conftest.py.
 url = None
 testapp = None
 __all__ = [
     'skipif', 'parametrize', 'environ', 'url', 'TestController',
     'ldap_lib_installed', 'pam_lib_installed', 'invalidate_all_caches',
     'TESTS_TMP_PATH', 'HG_REPO', 'GIT_REPO', 'NEW_HG_REPO', 'NEW_GIT_REPO',
     'HG_FORK', 'GIT_FORK', 'TEST_USER_ADMIN_LOGIN', 'TEST_USER_ADMIN_PASS',
     'TEST_USER_ADMIN_EMAIL', 'TEST_USER_REGULAR_LOGIN', 'TEST_USER_REGULAR_PASS',
@@ @@ -144,23 +143,15 @@ class TestController(object): @@
     """Pytest-style test controller"""
     # Note: pytest base classes cannot have an __init__ method
     @pytest.fixture(autouse=True)
     def app_fixture(self):
         config = pylons.test.pylonsapp.config
         url._push_object(URLGenerator(config['routes.map'], environ))
         pylons.app_globals._push_object(config['pylons.app_globals'])
         pylons.config._push_object(config)
         pylons.tmpl_context._push_object(ContextObj())
         # Initialize a translator for tests that utilize i18n
         translator = _get_translator(pylons.config.get('lang'))
         pylons.translator._push_object(translator)
         h = NullHandler()
         logging.getLogger("kallithea").addHandler(h)
-        self.app = TestApp(pylons.test.pylonsapp)
+        self.app = TestApp(testapp)
         return self.app
     def remove_all_notifications(self):
         # query().delete() does not (by default) trigger cascades
         # ( http://docs.sqlalchemy.org/en/rel_0_7/orm/collections.html#passive-deletes )
         # so delete the UserNotification first to ensure referential integrity.

kallithea/tests/conftest.py

➞

Show inline comments

 import os
 import sys
 import logging
 import pkg_resources
 import pkg_resources
 from paste.deploy import loadapp
 import pylons.test
 from pylons.i18n.translation import _get_translator
 from routes.util import URLGenerator
 from tg import config
 import pytest
 from kallithea.model.user import UserModel
 from kallithea.model.meta import Session
 from kallithea.model.db import Setting, User, UserIpMap
 from kallithea.tests.base import invalidate_all_caches, TEST_USER_REGULAR_LOGIN
 import kallithea.tests.base # FIXME: needed for setting testapp instance!!!
-from kallithea.tests.test_context import test_context
+from tg.util.webtest import test_context
 def pytest_configure():
     path = os.getcwd()
     sys.path.insert(0, path)
     pkg_resources.working_set.add_entry(path)
     # Disable INFO logging of test database creation, restore with NOTSET
     logging.disable(logging.INFO)
-    pylons.test.pylonsapp = loadapp('config:kallithea/tests/test.ini', relative_to=path)
+    kallithea.tests.base.testapp = loadapp('config:kallithea/tests/test.ini', relative_to=path)
     logging.disable(logging.NOTSET)
     # Initialize a translator for tests that utilize i18n
     translator = _get_translator(pylons.config.get('lang'))
     pylons.translator._push_object(translator)
     return pylons.test.pylonsapp
     kallithea.tests.base.url = URLGenerator(config['routes.map'], kallithea.tests.base.environ)
 @pytest.fixture
 def create_test_user():
     """Provide users that automatically disappear after test is over."""
     test_user_ids = []

kallithea/tests/functional/test_admin_notifications.py

➞

Show inline comments

@@ @@ -3,13 +3,13 @@ from kallithea.model.db import User @@
 from kallithea.model.user import UserModel
 from kallithea.model.notification import NotificationModel
 from kallithea.model.meta import Session
 from kallithea.lib import helpers as h
-from kallithea.tests.test_context import test_context
+from tg.util.webtest import test_context
 class TestNotificationsController(TestController):
     def setup_method(self, method):
         self.remove_all_notifications()
     def test_index(self, create_test_user):

kallithea/tests/functional/test_admin_permissions.py

➞

Show inline comments

@@ @@ -2,13 +2,13 @@ import time @@
 from kallithea.model.db import User, UserIpMap
 from kallithea.model.user import UserModel
 from kallithea.model.meta import Session
 from kallithea.tests.base import *
-from kallithea.tests.test_context import test_context
+from tg.util.webtest import test_context
 class TestAdminPermissionsController(TestController):
     def test_index(self):
         self.log_user()

kallithea/tests/functional/test_admin_users.py

➞

Show inline comments

@@ @@ -14,22 +14,23 @@ @@
 from sqlalchemy.orm.exc import NoResultFound, ObjectDeletedError
 import pytest
 from kallithea.tests.base import *
 from kallithea.tests.fixture import Fixture
 from kallithea.tests.test_context import test_context
 from kallithea.controllers.admin.users import UsersController
 from kallithea.model.db import User, Permission, UserIpMap, UserApiKeys
 from kallithea.lib.auth import check_password
 from kallithea.model.user import UserModel
 from kallithea.model import validators
 from kallithea.lib import helpers as h
 from kallithea.model.meta import Session
 from webob.exc import HTTPNotFound
 from tg.util.webtest import test_context
 fixture = Fixture()
 @pytest.fixture
 def user_and_repo_group_fail():
     username = 'repogrouperr'
     groupname = u'repogroup_fail'

kallithea/tests/functional/test_login.py

➞

Show inline comments

@@ @@ -13,13 +13,13 @@ from kallithea.lib import helpers as h @@
 from kallithea.model.api_key import ApiKeyModel
 from kallithea.model import validators
 from kallithea.model.db import User, Notification
 from kallithea.model.meta import Session
 from kallithea.model.user import UserModel
-from kallithea.tests.test_context import test_context
+from tg.util.webtest import test_context
 fixture = Fixture()
 class TestLoginController(TestController):
     def setup_method(self, method):

kallithea/tests/functional/test_my_account.py

➞

Show inline comments

@@ @@ -4,13 +4,13 @@ from kallithea.model.db import User, Use @@
 from kallithea.tests.base import *
 from kallithea.tests.fixture import Fixture
 from kallithea.lib import helpers as h
 from kallithea.model.user import UserModel
 from kallithea.model.meta import Session
-from kallithea.tests.test_context import test_context
+from tg.util.webtest import test_context
 fixture = Fixture()
 class TestMyAccountController(TestController):
     test_user_1 = 'testme'

kallithea/tests/functional/test_pullrequests.py

➞

Show inline comments

 import re
 import pytest
-from kallithea.tests.test_context import test_context
+from tg.util.webtest import test_context
 from kallithea.tests.base import *
 from kallithea.tests.fixture import Fixture
 from kallithea.model.db import User
 from kallithea.model.meta import Session

kallithea/tests/models/test_notifications.py

➞

Show inline comments

@@ @@ -11,13 +11,13 @@ from kallithea.model.user import UserMod @@
 from kallithea.model.meta import Session
 from kallithea.model.notification import NotificationModel, EmailNotificationModel
 import kallithea.lib.celerylib
 import kallithea.lib.celerylib.tasks
-from kallithea.tests.test_context import test_context
+from tg.util.webtest import test_context
 class TestNotifications(TestController):
     def setup_method(self, method):
         Session.remove()
         u1 = UserModel().create_or_update(username=u'u1',

kallithea/tests/other/test_libs.py

➞

Show inline comments

@@ @@ -28,13 +28,13 @@ Original author and date, and relevant c @@
 import datetime
 import hashlib
 import mock
 from kallithea.tests.base import *
 from kallithea.lib.utils2 import AttributeDict
 from kallithea.model.db import Repository
-from kallithea.tests.test_context import test_context
+from tg.util.webtest import test_context
 proto = 'http'
 TEST_URLS = [
     ('%s://127.0.0.1' % proto, ['%s://' % proto, '127.0.0.1'],
      '%s://127.0.0.1' % proto),
     ('%s://username@127.0.0.1' % proto, ['%s://' % proto, '127.0.0.1'],
@@ @@ -221,49 +221,49 @@ class TestLibs(TestController): @@
         assert '<div class="metatag" data-tag="tag">tag</div>' in res
     def test_alternative_gravatar(self):
         from kallithea.lib.helpers import gravatar_url
         _md5 = lambda s: hashlib.md5(s).hexdigest()
-        #mock pylons.tmpl_context
+        # mock tg.tmpl_context
         def fake_tmpl_context(_url):
             _c = AttributeDict()
             _c.visual = AttributeDict()
             _c.visual.use_gravatar = True
             _c.visual.gravatar_url = _url
             return _c
         fake_url = FakeUrlGenerator(current_url='https://example.com')
         with mock.patch('kallithea.config.routing.url', fake_url):
             fake = fake_tmpl_context(_url='http://example.com/{email}')
-            with mock.patch('pylons.tmpl_context', fake):
+            with mock.patch('tg.tmpl_context', fake):
                     from kallithea.config.routing import url
                     assert url.current() == 'https://example.com'
                     grav = gravatar_url(email_address='test@example.com', size=24)
                     assert grav == 'http://example.com/test@example.com'
             fake = fake_tmpl_context(_url='http://example.com/{email}')
-            with mock.patch('pylons.tmpl_context', fake):
+            with mock.patch('tg.tmpl_context', fake):
                 grav = gravatar_url(email_address='test@example.com', size=24)
                 assert grav == 'http://example.com/test@example.com'
             fake = fake_tmpl_context(_url='http://example.com/{md5email}')
-            with mock.patch('pylons.tmpl_context', fake):
+            with mock.patch('tg.tmpl_context', fake):
                 em = 'test@example.com'
                 grav = gravatar_url(email_address=em, size=24)
                 assert grav == 'http://example.com/%s' % (_md5(em))
             fake = fake_tmpl_context(_url='http://example.com/{md5email}/{size}')
-            with mock.patch('pylons.tmpl_context', fake):
+            with mock.patch('tg.tmpl_context', fake):
                 em = 'test@example.com'
                 grav = gravatar_url(email_address=em, size=24)
                 assert grav == 'http://example.com/%s/%s' % (_md5(em), 24)
             fake = fake_tmpl_context(_url='{scheme}://{netloc}/{md5email}/{size}')
-            with mock.patch('pylons.tmpl_context', fake):
+            with mock.patch('tg.tmpl_context', fake):
                 em = 'test@example.com'
                 grav = gravatar_url(email_address=em, size=24)
                 assert grav == 'https://example.com/%s/%s' % (_md5(em), 24)
     @parametrize('tmpl,repo_name,overrides,prefix,expected', [
         (Repository.DEFAULT_CLONE_URI, 'group/repo1', {}, '', 'http://vps1:8000/group/repo1'),

kallithea/tests/test.ini

➞

Show inline comments

@@ @@ -514,13 +514,13 @@ script_location = kallithea:alembic @@
 ################################
 ### LOGGING CONFIGURATION   ####
 ################################
 [loggers]
 keys = root, routes, kallithea, sqlalchemy, gearbox, beaker, templates, whoosh_indexer
+keys = root, routes, kallithea, sqlalchemy, tg, gearbox, beaker, templates, whoosh_indexer
 [handlers]
 keys = console, console_sql
 [formatters]
 keys = generic, color_formatter, color_formatter_sql
@@ @@ -555,12 +555,18 @@ propagate = 1 @@
 [logger_kallithea]
 level = DEBUG
 handlers =
 qualname = kallithea
 propagate = 1
 [logger_tg]
 level = DEBUG
 handlers =
 qualname = tg
 propagate = 1
 [logger_gearbox]
 level = DEBUG
 handlers =
 qualname = gearbox
 propagate = 1

setup.py

➞

Show inline comments

@@ @@ -36,13 +36,15 @@ is_windows = __platform__ in ['Windows'] @@
 requirements = [
     "alembic>=0.8.0,<0.9",
     "GearBox<1",
     "waitress>=0.8.8,<1.0",
     "webob>=1.7,<2",
     "Pylons>=1.0.0,<=1.0.2",
     "backlash >= 0.1.1, < 1.0.0",
     "TurboGears2 >= 2.3.10, < 3.0.0",
     "tgext.routes >= 0.2.0, < 1.0.0",
     "Beaker>=1.7.0,<2",
     "WebHelpers==1.3",
     "formencode>=1.2.4,<=1.2.6",
     "SQLAlchemy>=1.0,<1.1",
     "Mako>=0.9.0,<=1.0.0",
     "pygments>=1.5",
@@ @@ -53,12 +55,14 @@ requirements = [ @@
     "markdown==2.2.1",
     "docutils>=0.8.1",
     "URLObject==2.3.4",
     "Routes==1.13",
     "dulwich>=0.14.1",
     "mercurial>=2.9,<4.2",
     "decorator >= 3.3.2",
     "Paste >= 2.0.3, < 3.0",
+]
 if sys.version_info < (2, 7):
     requirements.append("importlib==1.0.1")
     requirements.append("argparse")
@@ @@ -148,15 +152,12 @@ setuptools.setup( @@
     kallithea-gist =   kallithea.bin.kallithea_gist:main
     kallithea-config = kallithea.bin.kallithea_config:main
     [paste.app_factory]
     main = kallithea.config.middleware:make_app
     [paste.app_install]
     main = pylons.util:PylonsInstaller
     [gearbox.commands]
     make-config=kallithea.lib.paster_commands.make_config:Command
     setup-db=kallithea.lib.paster_commands.setup_db:Command
     cleanup-repos=kallithea.lib.paster_commands.cleanup:Command
     update-repoinfo=kallithea.lib.paster_commands.update_repoinfo:Command
     make-rcext=kallithea.lib.paster_commands.make_rcextensions:Command

0 comments (0 inline, 0 general)