def test_get_pkginfo_non_toplevel(self):
from trac import core
import tracopt
pkginfo = util.get_pkginfo(trac)
self.assertEqual(pkginfo, util.get_pkginfo(util))
self.assertEqual(pkginfo, util.get_pkginfo(core))
self.assertEqual(pkginfo, util.get_pkginfo(tracopt))
def test_get_pkginfo_non_toplevel(self):
from trac import core
import tracopt
pkginfo = util.get_pkginfo(trac)
self.assertEqual(pkginfo, util.get_pkginfo(util))
self.assertEqual(pkginfo, util.get_pkginfo(core))
self.assertEqual(pkginfo, util.get_pkginfo(tracopt))
def test_file_metadata(self):
pkgname = 'TestModule_' + util.hex_entropy(16)
modname = pkgname.lower()
with open(os.path.join(self.dir, pkgname + '-0.1.egg-info'), 'w') as f:
f.write('Metadata-Version: 1.1\n'
'Name: %(pkgname)s\n'
'Version: 0.1\n'
'Author: Joe\n'
'Author-email: [email protected]\n'
'Home-page: http://example.org/\n'
'Summary: summary.\n'
'Description: description.\n'
'Provides: %(modname)s\n'
'Provides: %(modname)s.foo\n' % {
'pkgname': pkgname,
'modname': modname
})
os.mkdir(os.path.join(self.dir, modname))
for name in ('__init__.py', 'bar.py', 'foo.py'):
with open(os.path.join(self.dir, modname, name), 'w') as f:
f.write('# -*- coding: utf-8 -*-\n')
mod = __import__(modname, {}, {}, ['bar', 'foo'])
pkginfo = util.get_pkginfo(mod)
self.assertEqual('0.1', pkginfo['version'])
self.assertEqual('Joe', pkginfo['author'])
self.assertEqual('*****@*****.**', pkginfo['author_email'])
self.assertEqual('http://example.org/', pkginfo['home_page'])
self.assertEqual('summary.', pkginfo['summary'])
self.assertEqual('description.', pkginfo['description'])
self.assertEqual(pkginfo, util.get_pkginfo(mod.bar))
self.assertEqual(pkginfo, util.get_pkginfo(mod.foo))
def test_get_pkginfo_babel(self):
try:
import babel
import babel.core
dist = pkg_resources.get_distribution('Babel')
except:
pass
else:
pkginfo = util.get_pkginfo(babel)
self.assertNotEqual({}, pkginfo)
self.assertEqual(pkginfo, util.get_pkginfo(babel.core))
def test_get_pkginfo_pymysql(self):
try:
import pymysql
dist = pkg_resources.get_distribution('pymysql')
dist.get_metadata('top_level.txt')
except:
pass
else:
pkginfo = util.get_pkginfo(pymysql)
self.assertNotEqual({}, pkginfo)
self.assertEqual(pkginfo, util.get_pkginfo(pymysql.cursors))
def test_get_pkginfo_genshi(self):
try:
import genshi
import genshi.core
dist = pkg_resources.get_distribution('Genshi')
except:
pass
else:
pkginfo = util.get_pkginfo(genshi)
self.assertNotEqual({}, pkginfo)
self.assertEqual(pkginfo, util.get_pkginfo(genshi.core))
def test_get_pkginfo_babel(self):
try:
import babel
import babel.core
dist = pkg_resources.get_distribution('Babel')
except:
pass
else:
pkginfo = util.get_pkginfo(babel)
self.assertNotEqual({}, pkginfo)
self.assertEqual(pkginfo, util.get_pkginfo(babel.core))
def test_get_pkginfo_genshi(self):
try:
import genshi
import genshi.core
dist = pkg_resources.get_distribution('Genshi')
except:
pass
else:
pkginfo = util.get_pkginfo(genshi)
self.assertNotEqual({}, pkginfo)
self.assertEqual(pkginfo, util.get_pkginfo(genshi.core))
def test_get_pkginfo_psycopg2(self):
# python-psycopg2 deb package doesn't provide SOURCES.txt and
# top_level.txt
try:
import psycopg2
import psycopg2.extensions
dist = pkg_resources.get_distribution('psycopg2')
except:
pass
else:
pkginfo = util.get_pkginfo(psycopg2)
self.assertNotEqual({}, pkginfo)
self.assertEqual(pkginfo, util.get_pkginfo(psycopg2.extensions))
def test_get_pkginfo_psycopg2(self):
# python-psycopg2 deb package doesn't provide SOURCES.txt and
# top_level.txt
try:
import psycopg2
import psycopg2.extensions
dist = pkg_resources.get_distribution('psycopg2')
except:
pass
else:
pkginfo = util.get_pkginfo(psycopg2)
self.assertNotEqual({}, pkginfo)
self.assertEqual(pkginfo, util.get_pkginfo(psycopg2.extensions))
def test_get_pkginfo_mysqldb(self):
# MySQLdb's package name is "MySQL-Python"
try:
import MySQLdb
import MySQLdb.cursors
dist = pkg_resources.get_distribution('MySQL-Python')
dist.get_metadata('top_level.txt')
except:
pass
else:
pkginfo = util.get_pkginfo(MySQLdb)
self.assertNotEqual({}, pkginfo)
self.assertEqual(pkginfo, util.get_pkginfo(MySQLdb.cursors))
def test_get_pkginfo_mysqldb(self):
# MySQLdb's package name is "MySQL-Python"
try:
import MySQLdb
import MySQLdb.cursors
dist = pkg_resources.get_distribution('MySQL-Python')
dist.get_metadata('top_level.txt')
except:
pass
else:
pkginfo = util.get_pkginfo(MySQLdb)
self.assertNotEqual({}, pkginfo)
self.assertEqual(pkginfo, util.get_pkginfo(MySQLdb.cursors))
def get_system_info(self):
"""Yield a sequence of `(name, version)` tuples describing the name and
version information of external packages used by a component.
"""
import gdata
from trac.util import get_pkginfo
yield 'Google Data', get_pkginfo(gdata)['version']
def trac_version(self):
"""Returns the version of Trac.
:since: 1.2
"""
from trac import core, __version__
return get_pkginfo(core).get("version", __version__)
def functionalSuite(suite=None):
if not suite:
import trac.tests.functional
suite = trac.tests.functional.functionalSuite()
suite.addTest(TestWiki())
suite.addTest(TestWikiDelete())
suite.addTest(TestWikiAddAttachment())
suite.addTest(TestWikiPageManipulator())
suite.addTest(TestWikiHistory())
suite.addTest(TestWikiReadonlyAttribute())
suite.addTest(TestWikiRename())
suite.addTest(RegressionTestTicket4812())
suite.addTest(RegressionTestTicket8976())
suite.addTest(RegressionTestTicket10274())
suite.addTest(RegressionTestTicket10850())
suite.addTest(RegressionTestTicket10957())
suite.addTest(RegressionTestTicket11302())
suite.addTest(RegressionTestTicket11518())
if has_docutils:
import docutils
if get_pkginfo(docutils):
suite.addTest(ReStructuredTextWikiTest())
suite.addTest(ReStructuredTextCodeBlockTest())
else:
print("SKIP: reST wiki tests (docutils has no setuptools"
" metadata)")
else:
print("SKIP: reST wiki tests (no docutils)")
return suite
def get_system_info(self):
"""Yield a sequence of `(name, version)` tuples describing the name and
version information of external packages used by a component.
"""
import gdata
from trac.util import get_pkginfo
yield 'Google Data', get_pkginfo(gdata)['version']
def __init__(self):
self._version = have_pysqlite and \
get_pkginfo(sqlite).get('version',
'%d.%d.%s'
% sqlite.version_info)
self.error = None
self._extensions = None
def functionalSuite(suite=None):
if not suite:
import trac.tests.functional
suite = trac.tests.functional.functionalSuite()
suite.addTest(TestWiki())
suite.addTest(TestWikiAddAttachment())
suite.addTest(TestWikiPageManipulator())
suite.addTest(TestWikiHistory())
suite.addTest(TestWikiRename())
suite.addTest(RegressionTestTicket4812())
suite.addTest(RegressionTestTicket10274())
suite.addTest(RegressionTestTicket10850())
suite.addTest(RegressionTestTicket10957())
suite.addTest(RegressionTestTicket11302())
suite.addTest(RegressionTestTicket11518())
if has_docutils:
import docutils
if get_pkginfo(docutils):
suite.addTest(ReStructuredTextWikiTest())
suite.addTest(ReStructuredTextCodeBlockTest())
else:
print "SKIP: reST wiki tests (docutils has no setuptools metadata)"
else:
print "SKIP: reST wiki tests (no docutils)"
if ConfigObj:
suite.addTest(RegressionTestTicket8976())
else:
print "SKIP: RegressionTestTicket8976 (ConfigObj not installed)"
return suite
def __init__(self):
version = get_pkginfo(pygments).get('version')
# if installed from source, fallback to the hardcoded version info
if not version and hasattr(pygments, '__version__'):
version = pygments.__version__
self.env.systeminfo.append(('Pygments',version))
self._types = None
def __init__(self):
self._mssql_version = None
self._mssql_version = has_mssql and \
get_pkginfo(pymssql).get('version',
pymssql.__version__)
if self._mssql_version:
self.required = True
self.error = None
def get_system_info(self):
from trac import core, __version__ as VERSION
yield 'Trac', get_pkginfo(core).get('version', VERSION)
yield 'Python', sys.version
yield 'setuptools', setuptools.__version__
from trac.util.datefmt import pytz
if pytz is not None:
yield 'pytz', pytz.__version__
def get_system_info(self):
from trac import core, __version__ as VERSION
yield 'Trac', get_pkginfo(core).get('version', VERSION)
yield 'Python', sys.version
yield 'setuptools', setuptools.__version__
from trac.util.datefmt import pytz
if pytz is not None:
yield 'pytz', pytz.__version__
def get_system_info(self):
# Move implementation to httpbl, ip_blacklist and url_blacklist
# when support for Trac < 1.2 is dropped (#12294).
try:
import dns
except ImportError:
pass
else:
yield 'dnspython', get_pkginfo(dns)['version']
def get_system_info(self):
import genshi
info = get_pkginfo(genshi).get('version')
if hasattr(genshi, '_speedups'):
info += ' (with speedups)'
else:
info += ' (without speedups)'
yield 'Genshi', info
try:
import babel
except ImportError:
babel = None
if babel is not None:
info = get_pkginfo(babel).get('version')
if not get_available_locales():
info += " (translations unavailable)" # No i18n on purpose
self.log.warning("Locale data is missing")
yield 'Babel', info
def get_connection(self, path, log=None, user=None, password=None,
host=None, port=None, params={}):
cnx = PostgreSQLConnection(path, log, user, password, host, port,
params)
if not self._version:
self._version = get_pkginfo(psycopg).get('version',
psycopg.__version__)
self.env.systeminfo.append(('psycopg2', self._version))
self.required = True
return cnx
def __init__(self):
self.log.debug("SilverCity installed? %r", have_silvercity)
if have_silvercity:
self.env.systeminfo.append(('SilverCity',
get_pkginfo(SilverCity).get('version',
'?')))
# TODO: the above works only if setuptools was used to build
# SilverCity, which is not yet the case by default for 0.9.7.
# I've not been able to find an alternative way to get version.
self._types = None
def get_connection(self, path, log=None, user=None, password=None,
host=None, port=None, params={}):
cnx = PostgreSQLConnection(path, log, user, password, host, port,
params)
if not self._version:
self._version = get_pkginfo(psycopg).get('version',
psycopg.__version__)
self.env.systeminfo.append(('psycopg2', self._version))
self.required = True
return cnx
def get_connection(self, path, log=None, user=None, password=None,
host=None, port=None, params={}):
cnx = PostgreSQLConnection(path, log, user, password, host, port,
params)
if not self._version:
if has_psycopg:
self._version = get_pkginfo(psycopg).get('version',
psycopg.__version__)
name = 'psycopg2'
elif has_pgsql:
import pyPgSQL
self._version = get_pkginfo(pyPgSQL).get('version',
pyPgSQL.__version__)
name = 'pyPgSQL'
else:
name = 'unknown postgreSQL driver'
self._version = '?'
self.env.systeminfo.append((name, self._version))
return cnx
def get_connection(self, path, log=None, user=None, password=None, host=None, port=None, params={}):
cnx = MySQLConnection(path, log, user, password, host, port, params)
if not self._version:
self._version = get_pkginfo(MySQLdb).get("version", MySQLdb.__version__)
mysql_info = 'server: "%s", client: "%s", thread-safe: %s' % (
cnx.cnx.get_server_info(),
MySQLdb.get_client_info(),
MySQLdb.thread_safe(),
)
self.env.systeminfo.extend([("MySQL", mysql_info), ("MySQLdb", self._version)])
self.required = True
return cnx
def get_connection(self, path, log=None, params={}):
if not self._version:
self._version = get_pkginfo(sqlite).get(
'version', '%d.%d.%s' % sqlite.version_info)
self.env.systeminfo.extend([('SQLite', sqlite_version_string),
('pysqlite', self._version)])
if have_pysqlite == 1:
self.log.warning("Support for SQLite v2 and PySqlite 1.0.x "
"will be dropped in version 0.12, see "
"http://trac.edgewall.org/wiki/"
"PySqlite#UpgradingSQLitefrom2.xto3.x")
return SQLiteConnection(path, log, params)
def get_connection(self, path, log=None, user=None, password=None,
host=None, port=None, params={}):
cnx = MySQLConnection(path, log, user, password, host, port, params)
if not self._version:
self._version = get_pkginfo(MySQLdb).get('version',
MySQLdb.__version__)
mysql_info = 'server: "%s", client: "%s", thread-safe: %s' % \
(cnx.cnx.get_server_info(),
MySQLdb.get_client_info(),
MySQLdb.thread_safe())
self.env.systeminfo.extend([('MySQL', mysql_info),
('MySQLdb', self._version)])
self.required = True
return cnx
def get_connection(self, path, log=None, params={}):
if not self._version:
self._version = get_pkginfo(sqlite).get(
'version', '%d.%d.%s' % sqlite.version_info)
self.env.systeminfo.extend([('SQLite', sqlite_version_string),
('pysqlite', self._version)])
self.required = True
# construct list of sqlite extension libraries
if self._extensions is None:
self._extensions = []
for extpath in self.extensions:
if not os.path.isabs(extpath):
extpath = os.path.join(self.env.path, extpath)
self._extensions.append(extpath)
params['extensions'] = self._extensions
return SQLiteConnection(path, log, params)
def get_connection(self, path, log=None, params={}):
if not self._version:
self._version = get_pkginfo(sqlite).get(
'version', '%d.%d.%s' % sqlite.version_info)
self.env.systeminfo.extend([('SQLite', sqlite_version_string),
('pysqlite', self._version)])
self.required = True
# construct list of sqlite extension libraries
if self._extensions is None:
self._extensions = []
for extpath in self.extensions:
if not os.path.isabs(extpath):
extpath = os.path.join(self.env.path, extpath)
self._extensions.append(extpath)
params['extensions'] = self._extensions
return SQLiteConnection(path, log, params)
def functionalSuite(suite=None):
if not suite:
import trac.tests.functional.testcases
suite = trac.tests.functional.testcases.functionalSuite()
suite.addTest(TestWiki())
suite.addTest(RegressionTestTicket4812())
if has_docutils:
import docutils
if get_pkginfo(docutils):
suite.addTest(ReStructuredTextWikiTest())
suite.addTest(ReStructuredTextCodeBlockTest())
else:
print "SKIP: reST wiki tests (docutils has no setuptools metadata)"
else:
print "SKIP: reST wiki tests (no docutils)"
return suite
def functionalSuite(suite=None):
if not suite:
import trac.tests.functional.testcases
suite = trac.tests.functional.testcases.functionalSuite()
suite.addTest(TestWiki())
suite.addTest(TestWikiRename())
suite.addTest(RegressionTestTicket4812())
if has_docutils:
import docutils
if get_pkginfo(docutils):
suite.addTest(ReStructuredTextWikiTest())
suite.addTest(ReStructuredTextCodeBlockTest())
else:
print "SKIP: reST wiki tests (docutils has no setuptools metadata)"
else:
print "SKIP: reST wiki tests (no docutils)"
return suite
def setup_log(self):
"""Initialize the logging sub-system."""
from trac.log import logger_handler_factory
logtype = self.log_type
logfile = self.log_file
if logtype == 'file' and not os.path.isabs(logfile):
logfile = os.path.join(self.get_log_dir(), logfile)
format = self.log_format
if format:
format = format.replace('$(', '%(') \
.replace('%(path)s', self.path) \
.replace('%(basename)s', os.path.basename(self.path)) \
.replace('%(project)s', self.project_name)
self.log, self._log_handler = logger_handler_factory(
logtype, logfile, self.log_level, self.path, format=format)
from trac import core, __version__ as VERSION
self.log.info('-' * 32 + ' environment startup [Trac %s] ' + '-' * 32,
get_pkginfo(core).get('version', VERSION))
def setup_log(self):
"""Initialize the logging sub-system."""
from trac.log import logger_handler_factory
logtype = self.log_type
logfile = self.log_file
if logtype == 'file' and not os.path.isabs(logfile):
logfile = os.path.join(self.get_log_dir(), logfile)
format = self.log_format
logid = 'Trac.%s' % sha1(self.path).hexdigest()
if format:
format = format.replace('$(', '%(') \
.replace('%(path)s', self.path) \
.replace('%(basename)s', os.path.basename(self.path)) \
.replace('%(project)s', self.project_name)
self.log, self._log_handler = logger_handler_factory(
logtype, logfile, self.log_level, logid, format=format)
from trac import core, __version__ as VERSION
self.log.info('-' * 32 + ' environment startup [Trac %s] ' + '-' * 32,
get_pkginfo(core).get('version', VERSION))
def __init__(self, path, create=False, options=[]):
"""Initialize the Trac environment.
@param path: the absolute path to the Trac environment
@param create: if `True`, the environment is created and populated with
default data; otherwise, the environment is expected to
already exist.
@param options: A list of `(section, name, value)` tuples that define
configuration options
"""
ComponentManager.__init__(self)
self.path = path
self.setup_config(load_defaults=create)
self.setup_log()
from trac import core, __version__ as VERSION
trac_version = get_pkginfo(core).get('version', VERSION)
self.systeminfo = [
('Trac', trac_version),
('Python', sys.version),
('setuptools', setuptools.__version__),
]
self.log.info('-' * 32 + ' environment startup [Trac %s] ' + '-' * 32,
trac_version)
self._href = self._abs_href = None
from trac.loader import load_components
plugins_dir = self.shared_plugins_dir
load_components(self, plugins_dir and (plugins_dir,))
if create:
self.create(options)
else:
self.verify()
if create:
for setup_participant in self.setup_participants:
setup_participant.environment_created()
self._known_users_cache_time = 0
self._known_users_cache = None
def setup_log(self):
"""Initialize the logging sub-system."""
from trac.log import logger_handler_factory
logtype = self.log_type
logfile = self.log_file
format = self.log_format
self.parent.log.debug("Log type '%s' for product '%s'", logtype,
self.product.prefix)
# Force logger inheritance on identical configuration
if (logtype, logfile,
format) == (self.parent.log_type, self.parent.log_file,
self.parent.log_format):
logtype = 'inherit'
if logtype == 'inherit':
self.log = self.parent.log
self._log_handler = self.parent._log_handler
self.parent.log.warning(
"Inheriting parent logger for product '%s'",
self.product.prefix)
else:
if logtype == 'file' and not os.path.isabs(logfile):
logfile = os.path.join(self.get_log_dir(), logfile)
logid = 'Trac.%s.%s' % \
(sha1(self.parent.path).hexdigest(), self.product.prefix)
if format:
format = format.replace('$(', '%(') \
.replace('%(path)s', self.path) \
.replace('%(basename)s', os.path.basename(self.path)) \
.replace('%(project)s', self.project_name)
self.log, self._log_handler = logger_handler_factory(
logtype, logfile, self.log_level, logid, format=format)
from trac import core, __version__ as VERSION
self.log.info(
'-' * 32 + ' product %s environment startup [Trac %s] ' + '-' * 32,
self.product.prefix,
get_pkginfo(core).get('version', VERSION))
def setup_log(self):
"""Initialize the logging sub-system."""
from trac.log import logger_handler_factory
logtype = self.log_type
logfile = self.log_file
format = self.log_format
self.parent.log.debug("Log type '%s' for product '%s'",
logtype, self.product.prefix)
# Force logger inheritance on identical configuration
if (logtype, logfile, format) == (self.parent.log_type,
self.parent.log_file, self.parent.log_format):
logtype = 'inherit'
if logtype == 'inherit':
self.log = self.parent.log
self._log_handler = self.parent._log_handler
self.parent.log.info("Inheriting parent logger for product '%s'",
self.product.prefix)
else:
if logtype == 'file' and not os.path.isabs(logfile):
logfile = os.path.join(self.get_log_dir(), logfile)
logid = 'Trac.%s.%s' % \
(sha1(self.parent.path).hexdigest(), self.product.prefix)
if format:
format = format.replace('$(', '%(') \
.replace('%(path)s', self.path) \
.replace('%(basename)s', os.path.basename(self.path)) \
.replace('%(project)s', self.project_name)
self.log, self._log_handler = logger_handler_factory(
logtype, logfile, self.log_level, logid, format=format)
from trac import core, __version__ as VERSION
self.log.info('-' * 32 +
' product %s environment startup [Trac %s] ' +
'-' * 32,
self.product.prefix,
get_pkginfo(core).get('version', VERSION))
def get_connection(self, path, log=None, params={}):
if not self._version:
self._version = get_pkginfo(sqlite).get(
'version', '%d.%d.%s' % sqlite.version_info)
self.env.systeminfo.extend([('SQLite', sqlite_version_string),
('pysqlite', self._version)])
self.required = True
# construct list of sqlite extension libraries
if self._extensions is None:
self._extensions = []
for extpath in self.extensions:
if not os.path.isabs(extpath):
extpath = os.path.join(self.env.path, extpath)
self._extensions.append(extpath)
params['extensions'] = self._extensions
if path == ':memory:':
try:
self.memory_cnx.cursor()
except (AttributeError, sqlite.DatabaseError):
# memory_cnx is None or database connection closed.
self.memory_cnx = SQLiteConnection(path, log, params)
return self.memory_cnx
else:
return SQLiteConnection(path, log, params)
# All configuration values have a default value; values that are
# commented out serve to show the default value.
import os
import sys
from datetime import datetime
from trac.util import get_pkginfo
try:
from pygments.lexers.templates import DjangoLexer
html_jinja_lexer = DjangoLexer()
except ImportError:
html_jinja_lexer = None
pkg_info = get_pkginfo(sys.modules['trac'])
# General substitutions.
project = 'Trac'
copyright = '%s, Edgewall Software' % datetime.now().year
url = pkg_info['home_page']
# The default replacements for |version| and |release|, also used in various
# other places throughout the built documents.
#
# The short X.Y version.
version = pkg_info['version'].split('dev')[0]
# The full version, including alpha/beta/rc tags.
release = pkg_info['version']
# Devel or Release mode for the documentation (if devel, include TODOs,
try:
import psycopg2 as psycopg
import psycopg2.extensions
from psycopg2 import DataError, ProgrammingError
from psycopg2.extensions import register_type, UNICODE, \
register_adapter, AsIs, QuotedString
except ImportError:
has_psycopg = False
psycopg = None
psycopg2_version = None
else:
has_psycopg = True
register_type(UNICODE)
register_adapter(Markup, lambda markup: QuotedString(unicode(markup)))
register_adapter(type(empty), lambda empty: AsIs("''"))
psycopg2_version = get_pkginfo(psycopg).get('version', psycopg.__version__)
if hasattr(psycopg, 'libpq_version'):
_libpq_pathname = None
else:
try:
_libpq_pathname = find_library('pq' if os.name != 'nt' else 'libpq')
except Exception:
_libpq_pathname = None
_like_escape_re = re.compile(r'([/_%])')
# Mapping from "abstract" SQL types to DB-specific types
_type_map = {
'int64': 'bigint',
}
def get_system_info(self):
if have_silvercity:
yield 'SilverCity', get_pkginfo(SilverCity).get('version', '?')
def get_system_info(self):
version = get_pkginfo(pygments).get('version')
# if installed from source, fallback to the hardcoded version info
if not version and hasattr(pygments, '__version__'):
version = pygments.__version__
yield 'Pygments', version
def __init__(self):
import genshi
self.env.systeminfo.append(('Genshi',
get_pkginfo(genshi).get('version')))
def get_plugin_info(env, include_core=False):
"""Return package information about Trac core and installed plugins."""
path_sources = {}
def find_distribution(module):
name = module.__name__
path = get_module_path(module)
sources = path_sources.get(path)
if sources is None:
sources = path_sources[path] = get_sources(path)
dist = sources.get(name.replace('.', '/') + '.py')
if dist is None:
dist = sources.get(name.replace('.', '/') + '/__init__.py')
if dist is None:
# This is a plain Python source file, not an egg
dist = pkg_resources.Distribution(project_name=name,
version='',
location=module.__file__)
return dist
plugins_dir = env.plugins_dir
plugins = {}
from trac.core import ComponentMeta
for component in ComponentMeta._components:
module = sys.modules[component.__module__]
dist = find_distribution(module)
plugin_filename = None
if os.path.realpath(os.path.dirname(dist.location)) == plugins_dir:
plugin_filename = os.path.basename(dist.location)
if dist.project_name not in plugins:
readonly = True
if plugin_filename and os.access(dist.location, os.F_OK + os.W_OK):
readonly = False
# retrieve plugin metadata
info = get_pkginfo(dist)
if not info:
info = {}
for k in ('author', 'author_email', 'home_page', 'url',
'license', 'summary', 'trac'):
v = getattr(module, k, '')
if v and isinstance(v, basestring):
if k in ('home_page', 'url'):
k = 'home_page'
v = v.replace('$', '').replace('URL: ', '')
else:
v = to_unicode(v)
info[k] = v
else:
# Info found; set all those fields to "None" that have the
# value "UNKNOWN" as this is the value for fields that
# aren't specified in "setup.py"
for k in info:
if info[k] == 'UNKNOWN':
info[k] = ''
else:
# Must be encoded as unicode as otherwise Genshi
# may raise a "UnicodeDecodeError".
info[k] = to_unicode(info[k])
# retrieve plugin version info
version = dist.version
if not version:
version = (getattr(module, 'version', '')
or getattr(module, 'revision', ''))
# special handling for "$Rev$" strings
if version != '$Rev$':
version = version.replace('$', '').replace('Rev: ', 'r')
else: # keyword hasn't been expanded
version = ''
plugins[dist.project_name] = {
'name': dist.project_name,
'version': version,
'path': dist.location,
'plugin_filename': plugin_filename,
'readonly': readonly,
'info': info,
'modules': {},
}
modules = plugins[dist.project_name]['modules']
if module.__name__ not in modules:
summary, description = get_doc(module)
plugins[dist.project_name]['modules'][module.__name__] = {
'summary': summary,
'description': description,
'components': {},
}
full_name = module.__name__ + '.' + component.__name__
summary, description = get_doc(component)
c = component
if c in env and not issubclass(c, env.__class__):
c = component(env)
modules[module.__name__]['components'][component.__name__] = {
'full_name': full_name,
'summary': summary,
'description': description,
'enabled': env.is_component_enabled(component),
'required': getattr(c, 'required', False),
}
if not include_core:
for name in list(plugins):
if name.lower() == 'trac':
plugins.pop(name)
return sorted(plugins.itervalues(),
key=lambda p:
(p['name'].lower() != 'trac', p['name'].lower()))
def test_get_pkginfo_trac(self):
pkginfo = util.get_pkginfo(trac)
self.assertEqual(trac.__version__, pkginfo.get('version'))
self.assertNotEqual({}, pkginfo)
def get_system_info(self):
yield 'Pygments', get_pkginfo(pygments).get('version')
from trac.db.util import ConnectionWrapper, IterableCursor
from trac.util import as_int, get_pkginfo
from trac.util.html import Markup
from trac.util.compat import close_fds
from trac.util.text import exception_to_unicode, to_unicode
from trac.util.translation import _
_like_escape_re = re.compile(r'([/_%])')
try:
import pymysql
except ImportError:
pymysql = None
pymsql_version = None
else:
pymsql_version = get_pkginfo(pymysql).get('version', pymysql.__version__)
class MySQLUnicodeCursor(pymysql.cursors.Cursor):
def _convert_row(self, row):
return tuple(
v.decode('utf-8') if isinstance(v, str) else v for v in row)
def fetchone(self):
row = super(MySQLUnicodeCursor, self).fetchone()
return self._convert_row(row) if row else None
def fetchmany(self, num):
rows = super(MySQLUnicodeCursor, self).fetchmany(num)
return [self._convert_row(row) for row in rows] \
if rows is not None else []
def _render_view(self, req):
plugins = {}
plugins_dir = os.path.realpath(os.path.join(self.env.path, 'plugins'))
plugins_dir = os.path.normcase(plugins_dir) # needs to match loader.py
from trac.core import ComponentMeta
for component in ComponentMeta._components:
module = sys.modules[component.__module__]
dist = self._find_distribution(module)
plugin_filename = None
if os.path.realpath(os.path.dirname(dist.location)) == plugins_dir:
plugin_filename = os.path.basename(dist.location)
description = inspect.getdoc(component)
if description:
description = to_unicode(description).split('.', 1)[0] + '.'
if dist.project_name not in plugins:
readonly = True
if plugin_filename and os.access(dist.location,
os.F_OK + os.W_OK):
readonly = False
# retrieve plugin metadata
info = get_pkginfo(dist)
if not info:
info = {'summary': description}
for k in ('author author_email home_page url license trac'
.split()):
v = getattr(module, k, '')
if v:
if k == 'home_page' or k == 'url':
k = 'home_page'
v = v.replace('$', '').replace('URL: ', '')
info[k] = v
# retrieve plugin version info
version = dist.version
if not version:
version = (getattr(module, 'version', '') or
getattr(module, 'revision', ''))
# special handling for "$Rev$" strings
version = version.replace('$', '').replace('Rev: ', 'r')
plugins[dist.project_name] = {
'name': dist.project_name, 'version': version,
'path': dist.location, 'description': description,
'plugin_filename': plugin_filename, 'readonly': readonly,
'info': info, 'components': [],
'settingheader': dist.project_name,
'settings': []
}
self.getSettings(component, plugins[dist.project_name]['settings'])
prjconf = Configuration(conf.global_conf_path)
pstate = self.get_project_component_state(component, prjconf)
ostate = self.get_project_component_state(component, self.config)
plugins[dist.project_name]['components'].append({
'name': component.__name__, 'module': module.__name__,
'description': description,
'enabled': self.is_plugin_enabled(ostate),
'required': self.is_plugin_required(ostate),
'view': self.is_plugin_shown(ostate),
'penabled': self.is_plugin_enabled(pstate),
'prequired': self.is_plugin_required(pstate),
'pview': self.is_plugin_shown(pstate),
})
def component_order(a, b):
c = cmp(len(a['module'].split('.')), len(b['module'].split('.')))
if c == 0:
c = cmp(a['module'].lower(), b['module'].lower())
if c == 0:
c = cmp(a['name'].lower(), b['name'].lower())
return c
for category in plugins:
plugins[category]['components'].sort(component_order)
plugin_list = [plugins['Trac']]
addons = [key for key in plugins.keys() if key != 'Trac']
addons.sort()
plugin_list += [plugins[category] for category in addons]
data = {
'plugins': plugin_list,
'readonly': not os.access(plugins_dir, os.F_OK + os.W_OK),
}
return 'admin_home_plugins.html', data
def __init__(self):
self._mysql_version = None
self._mysqldb_version = has_mysqldb and \
get_pkginfo(MySQLdb).get('version',
MySQLdb.__version__)
self.error = None
try:
import psycopg2 as psycopg
import psycopg2.extensions
from psycopg2 import DataError, ProgrammingError
from psycopg2.extensions import register_type, UNICODE, \
register_adapter, AsIs, QuotedString
except ImportError:
has_psycopg = False
psycopg2_version = None
else:
has_psycopg = True
register_type(UNICODE)
register_adapter(Markup, lambda markup: QuotedString(unicode(markup)))
register_adapter(type(empty), lambda empty: AsIs("''"))
psycopg2_version = get_pkginfo(psycopg).get('version',
psycopg.__version__)
_like_escape_re = re.compile(r'([/_%])')
# Mapping from "abstract" SQL types to DB-specific types
_type_map = {
'int64': 'bigint',
}
def assemble_pg_dsn(path, user=None, password=None, host=None, port=None):
"""Quote the parameters and assemble the DSN."""
def quote(value):
if not isinstance(value, basestring):
value = unicode(value)
return "'%s'" % value.replace('\\', r'\\').replace("'", r"\'")
def get_plugin_info(env, include_core=False):
"""Return package information about Trac core and installed plugins."""
path_sources = {}
def find_distribution(module):
name = module.__name__
path = get_module_path(module)
sources = path_sources.get(path)
if sources is None:
sources = path_sources[path] = get_sources(path)
dist = sources.get(name.replace('.', '/') + '.py')
if dist is None:
dist = sources.get(name.replace('.', '/') + '/__init__.py')
if dist is None:
# This is a plain Python source file, not an egg
dist = pkg_resources.Distribution(project_name=name,
version='',
location=module.__file__)
return dist
plugins_dir = get_plugins_dir(env)
plugins = {}
from trac.core import ComponentMeta
for component in ComponentMeta._components:
module = sys.modules[component.__module__]
dist = find_distribution(module)
plugin_filename = None
if os.path.realpath(os.path.dirname(dist.location)) == plugins_dir:
plugin_filename = os.path.basename(dist.location)
if dist.project_name not in plugins:
readonly = True
if plugin_filename and os.access(dist.location,
os.F_OK + os.W_OK):
readonly = False
# retrieve plugin metadata
info = get_pkginfo(dist)
if not info:
info = {}
for k in ('author', 'author_email', 'home_page', 'url',
'license', 'trac'):
v = getattr(module, k, '')
if v and isinstance(v, basestring):
if k == 'home_page' or k == 'url':
k = 'home_page'
v = v.replace('$', '').replace('URL: ', '')
else:
v = to_unicode(v)
info[k] = v
else:
# Info found; set all those fields to "None" that have the
# value "UNKNOWN" as this is the value for fields that
# aren't specified in "setup.py"
for k in info:
if info[k] == 'UNKNOWN':
info[k] = ''
else:
# Must be encoded as unicode as otherwise Genshi
# may raise a "UnicodeDecodeError".
info[k] = to_unicode(info[k])
# retrieve plugin version info
version = dist.version
if not version:
version = (getattr(module, 'version', '') or
getattr(module, 'revision', ''))
# special handling for "$Rev$" strings
version = version.replace('$', '').replace('Rev: ', 'r')
plugins[dist.project_name] = {
'name': dist.project_name, 'version': version,
'path': dist.location, 'plugin_filename': plugin_filename,
'readonly': readonly, 'info': info, 'modules': {},
}
modules = plugins[dist.project_name]['modules']
if module.__name__ not in modules:
summary, description = get_doc(module)
plugins[dist.project_name]['modules'][module.__name__] = {
'summary': summary, 'description': description,
'components': {},
}
full_name = module.__name__ + '.' + component.__name__
summary, description = get_doc(component)
c = component
if c in env and not issubclass(c, env.__class__):
c = component(env)
modules[module.__name__]['components'][component.__name__] = {
'full_name': full_name,
'summary': summary, 'description': description,
'enabled': env.is_component_enabled(component),
'required': getattr(c, 'required', False),
}
if not include_core:
for name in plugins.keys():
if name.lower() == 'trac':
plugins.pop(name)
return sorted(plugins.itervalues(),
key=lambda p: (p['name'].lower() != 'trac',
p['name'].lower()))
from trac.util import get_pkginfo, getuser, lazy
from trac.util.translation import _, tag_
_like_escape_re = re.compile(r'([/_%])')
_glob_escape_re = re.compile(r'[*?\[]')
try:
import pysqlite2.dbapi2 as sqlite
except ImportError:
import sqlite3 as sqlite
sqlite_version = sqlite.sqlite_version_info
sqlite_version_string = sqlite.sqlite_version
pysqlite_version = sqlite.version_info
pysqlite_version_string = get_pkginfo(sqlite).get(
'version', '%d.%d.%s' % pysqlite_version)
min_sqlite_version = (3, 0, 0)
min_pysqlite_version = (2, 4, 1) # version provided by Python 2.6
class PyFormatCursor(sqlite.Cursor):
def _rollback_on_error(self, function, *args, **kwargs):
try:
return function(self, *args, **kwargs)
except sqlite.DatabaseError:
self.cnx.rollback()
raise
def execute(self, sql, args=None):
if args:
sql = sql % (('?', ) * len(args))
def trac_version(self):
"""Returns the version of Trac.
:since: 1.2
"""
from trac import core, __version__
return get_pkginfo(core).get('version', __version__)
# containing dir.
#
# The contents of this file are pickled, so don't put values in the
# namespace that aren't pickleable (module imports are okay, they're
# removed automatically).
#
# All configuration values have a default value; values that are
# commented out serve to show the default value.
import os
import sys
from datetime import datetime
from trac.util import get_pkginfo
pkg_info = get_pkginfo(sys.modules['trac'])
# General substitutions.
project = 'Trac'
copyright = '%s, Edgewall Software' % datetime.now().year
url = pkg_info['home_page']
# The default replacements for |version| and |release|, also used in various
# other places throughout the built documents.
#
# The short X.Y version.
version = pkg_info['version'].split('dev')[0]
# The full version, including alpha/beta/rc tags.
release = pkg_info['version']
# Devel or Release mode for the documentation (if devel, include TODOs,
def get_system_info(self):
if has_textile:
# textile.__version__ is available since 2.1.6
version = get_pkginfo(textile).get('version') or \
getattr(textile, '__version__', 'n/a')
yield 'Textile', version
from trac.util.translation import _, tag_
_like_escape_re = re.compile(r'([/_%])')
_glob_escape_re = re.compile(r'[*?\[]')
try:
import pysqlite2.dbapi2 as sqlite
except ImportError:
import sqlite3 as sqlite
sqlite_version = sqlite.sqlite_version_info
sqlite_version_string = sqlite.sqlite_version
pysqlite_version = sqlite.version_info
pysqlite_version_string = get_pkginfo(sqlite).get('version',
'%d.%d.%s'
% pysqlite_version)
min_sqlite_version = (3, 0, 0)
min_pysqlite_version = (2, 4, 1) # version provided by Python 2.6
class PyFormatCursor(sqlite.Cursor):
def _rollback_on_error(self, function, *args, **kwargs):
try:
return function(self, *args, **kwargs)
except sqlite.DatabaseError:
self.cnx.rollback()
raise
def execute(self, sql, args=None):
if args:
def get_system_info(self):
version = get_pkginfo(pygments).get('version')
# if installed from source, fallback to the hardcoded version info
if not version and hasattr(pygments, '__version__'):
version = pygments.__version__
yield 'Pygments', version
