def generate_ini_files(self, source, target):
print "generate_ini_files"
egg = target.anchor
for name in ['development.ini']:
egg.factories[name] = JinjaTemplate
if name not in egg.keys():
egg[name] = JinjaTemplate()
egg[name].template = templatepath(name + '.jinja')
egg[name].params = {'package':source.name,
'host':'0.0.0.0',
'port':'8080'}
ept = """[paste.app_factory]
main = %s:main"""
tok = token('entry_points', True, defs=[])
tok.defs.append(ept % dotted_path(source))
def gsprofilesetuphandlers(self, source, target):
"""Create jsregistry.xml
"""
package = target.anchor
default = package['profiles']['default']
egg = egg_source(source)
egg_name = egg.name
path = dotted_path(egg) + '.setuphandlers.install'
markerfilename = '%s_marker.txt' % dotted_path(egg)
#create setuphandlers.py
setupname = 'setuphandlers.py'
if setupname not in package.keys():
setup = JinjaTemplate()
package[setupname] = setup
setup.template = 'agx.generator.plone:templates/setuphandlers.py.jinja'
setup.params = {'egg':path, 'markerfilename':markerfilename}
#create the markerfile
if not markerfilename in default.keys():
markerfile = default[markerfilename] = DTMLTemplate()
markerfile.template = \
'agx.generator.plone:templates/productname_marker.txt'
# read or create import_steps.xml
if 'import_steps.xml' in default:
xml = default['import_steps.xml']
else:
xml = default['import_steps.xml'] = DTMLTemplate()
# set template used for import_steps.xml
xml.template = 'agx.generator.plone:templates/import_steps.xml'
# set template params
xml.params = {
'eggid' : path,
'handler' : path,
'handlertitle' : 'Installer for ' + dotted_path(egg),
'version': '1', # XXX: extend profile with import step version.
'description':'',# XXX: extend profile with import step version.
}
def gsprofilesetuphandlers(self, source, target):
"""Create jsregistry.xml
"""
package = target.anchor
default = package['profiles']['default']
egg = egg_source(source)
egg_name = egg.name
path = dotted_path(egg) + '.setuphandlers.install'
markerfilename = '%s_marker.txt' % dotted_path(egg)
#create setuphandlers.py
setupname = 'setuphandlers.py'
if setupname not in package.keys():
setup = JinjaTemplate()
package[setupname] = setup
setup.template = 'agx.generator.plone:templates/setuphandlers.py.jinja'
setup.params = {'egg': path, 'markerfilename': markerfilename}
#create the markerfile
if not markerfilename in default.keys():
markerfile = default[markerfilename] = DTMLTemplate()
markerfile.template = \
'agx.generator.plone:templates/productname_marker.txt'
# read or create import_steps.xml
if 'import_steps.xml' in default:
xml = default['import_steps.xml']
else:
xml = default['import_steps.xml'] = DTMLTemplate()
# set template used for import_steps.xml
xml.template = 'agx.generator.plone:templates/import_steps.xml'
# set template params
xml.params = {
'eggid': path,
'handler': path,
'handlertitle': 'Installer for ' + dotted_path(egg),
'version': '1', # XXX: extend profile with import step version.
'description': '', # XXX: extend profile with import step version.
}
def ploneselfcontainedbuildout(self, source, target):
if not source.stereotype('buildout:plone_self_contained'):
return
root = target.anchor
root.factories['buildout.cfg'] = JinjaTemplate
root.factories['bootstrap.py'] = JinjaTemplate
if 'buildout.cfg' in root:
return # dont overwrite the .cfg
else:
buildout = root['buildout.cfg'] = JinjaTemplate()
buildout.template = templatepath('buildout.cfg.jinja')
buildout.params['package'] = source.name
if 'bootstrap.py' in root:
bootstrap = root['bootstrap.py']
else:
bootstrap = root['bootstrap.py'] = JinjaTemplate()
bootstrap.template = templatepath('bootstrap.py.jinja')
bootstrap.params = {}
def pyramid_include(self, source, target):
#creates a pyramid includeme hook if <<pyramid_include>> is applied on the root package
#egg=egg_source(source)
targetegg=read_target_node(source,target.target)
db_attribute_name='db'
tgv=source.stereotype('sql:pyramid_include').taggedvalue('db_attribute_name')
if tgv:
db_attribute_name=tgv.value
fname='pyramid_include.py'
if fname not in targetegg.keys():
templ=JinjaTemplate()
templ.template=templatepath('pyramid_include.py.jinja')
templ.params={
'db_attribute_name':db_attribute_name}
targetegg[fname]=templ
init=targetegg['__init__.py']
imps=Imports(init)
imps.set('pyramid_include','includeme')
def generate_sqlalchemy_config(self, source, target):
tgt = read_target_node(source, target.target)
if IModule.providedBy(tgt):
# target is a module, then its ok
module = tgt
target_dir = module.parent
else:
# fetch __init__.py
module = tgt['__init__.py']
target_dir = tgt
# first lets create sqla_config.py that does all the config situps
fname = 'sqla_config.py'
package_name = implicit_dotted_path(source)
templ = JinjaTemplate()
target_dir.factories[fname] = JinjaTemplate
templ.template = templatepath(fname) + '.jinja'
target_dir[fname] = templ
target_dir[fname].params = {'engine_name':'default', 'package_name':dotted_path(source)}
# now lets call config_db from the __init__.py
imps = Imports(module)
imps.set('sqla_config', 'config_db')
main = module.functions('main')[0]
term = 'config.make_wsgi_app'
make_app = main.blocks(term)[0]
lines = make_app.lines
# find occurrence of line in block
index = -1
found = False
for i in range(len(lines)):
if term in lines[i]:
index = i
if 'config_db' in lines[i]:
found = True
tok = token('config', True, main=main, module=module)
if index != -1 and not found:
lines.insert(index, 'config_db(config)')
def sql_sample(self, source, target):
if not source.stereotype('sql:z3c_saconfig'):
return
root=target.anchor
tgv = TaggedValues(source)
engine_name = tgv.direct('engine_name', 'sql:z3c_saconfig', 'default')
engine_url = tgv.direct(
'engine_url', 'sql:z3c_saconfig', 'sqlite:///test.db')
session_name = tgv.direct('session_name', 'sql:z3c_saconfig', 'default')
# write the readme
fname = 'sample-sqlalchemy.py'
if fname not in root.keys():
readme = JinjaTemplate()
readme.template = templatepath(fname + '.jinja')
readme.params = {
'engine_name': engine_name,
'engine_url': engine_url,
'session_name': session_name,
'packagename': dotted_path(source),
}
root[fname] = readme
def sqlrelations_relations(self, source, target):
"""generate relations.
"""
if source.stereotype('pyegg:stub'):
return
if not source.stereotype('sql:sql_content'):
return
targetclass = read_target_node(source, target.target)
module = targetclass.parent
directory = module.parent
# get the last attribute and append there the relations
attrs = targetclass.attributes()
attrnames = [att.targets[0] for att in attrs]
try:
lastattr = targetclass.attributes()[-1]
except IndexError:
lastattr = None
outgoing_relations = token(str(source.uuid),
True, outgoing_relations=[]).outgoing_relations
imps = Imports(module)
if outgoing_relations:
imps.set('sqlalchemy.orm', [['relationship', None]])
for relend in outgoing_relations:
assoc = relend.association
if relend==relend.association.memberEnds[0]:
otherend = relend.association.memberEnds[1]
else:
otherend = relend.association.memberEnds[0]
#Association classes are handled seperately
#once we support association tables, we have to handle it here
tgv = TaggedValues(assoc)
if IAssociationClass.providedBy(assoc):
# tgv = TaggedValues(otherend) We need to build support for tgvs on
# member ends later
klass = relend.type
otherclass = relend.association
relname = token(str(otherend.uuid), True, relname=otherend.name+'_associations').relname
else:
klass = relend.type
otherclass = otherend.type
relname = otherend.name
if relname not in attrnames:
attr = Attribute()
attr.__name__ = str(attr.uuid)
if lastattr:
targetclass.insertafter(attr, lastattr)
else:
targetclass.insertfirst(attr)
attr.targets = [relname]
options = {}
# collect options for relationship
if otherend.aggregationkind == 'composite':
options['cascade'] = "'all, delete-orphan'"
if assoc.stereotype('sql:ordered'):
order_by = tgv.direct('order_by', 'sql:ordered', None)
if not order_by:
msg = 'when setting a relation ordered you have to ' +\
'specify order_by!'
raise ValueError(msg)
# if not prefixed, lets prefix it
if not '.' in order_by:
order_by = '%s.%s' % (otherclass.name, order_by)
options['order_by'] = "'%s'" % order_by
if assoc.stereotype('sql:attribute_mapped'):
keyname = tgv.direct('key', 'sql:attribute_mapped', None)
if not keyname:
msg = 'when defining attribute_mapped you have to ' + \
'specify a key'
raise ValueError(msg)
if assoc.stereotype('sql:ordered'):
# support for ordered mapped collection
# in this case we have to provide our own collection
# see http://docs.sqlalchemy.org/en/rel_0_7/orm/collections.html,
# secion 'Custom Dictionary-Based Collections'
fname = 'orderedcollection.py'
if fname not in directory:
src = JinjaTemplate()
src.template = templatepath(fname + '.jinja')
src.params = {}
directory[fname] = src
# XXX: so that emptymoduleremoval doesnt kick the
# template out better would be that jinjatemplates
# dont get removed at all
token('pymodules', True, modules=set()).modules.add(src)
options['collection_class'] = \
"ordered_attribute_mapped_collection('%s')" % keyname
imps.set('orderedcollection',
[['ordered_attribute_mapped_collection', None]])
# unordered
else:
options['collection_class'] = \
"attribute_mapped_collection('%s')" % keyname
imps.set('sqlalchemy.orm.collections',
[['attribute_mapped_collection', None]])
# make the primaryjoin stmt
if 1 or not IAssociationClass.providedBy(relend.association):
tok = token(str(relend.uuid), True, joins=[])
if tok.joins:
options['primaryjoin'] = "'%s'" % ','.join(tok.joins)
# XXX: .navigable isn't yet correctly parsed from uml, thus the
# hardcoding
if True or relend.navigable:
options['backref'] = "'%s'" % relend.name.lower()
if assoc.stereotype('sql:lazy'):
laziness = tgv.direct('laziness', 'sql:lazy', 'dynamic')
options['lazy'] = "'%s'" % laziness
#convert options into keyword params
oparray = []
for k in options:
oparray.append('%s = %s' % (k, options[k]))
attr.value = "relationship('%s', %s)" % (
otherclass.name, ', '.join(oparray))
def eggdocuments(self, source, target):
"""Create egg ``setup.py`` and default documents.
"""
root = target.anchor
# setup.py
root.factories['setup.py'] = JinjaTemplate
tgv = TaggedValues(source)
version = tgv.direct('version', 'pyegg:pyegg', '1.0')
project = source.name
cp = tgv.direct('copyright', 'pyegg:pyegg', '')
cp = cp.split(',')
cp = [line.strip() for line in cp]
description = tgv.direct('description', 'pyegg:pyegg', '')
classifiers = tgv.direct('classifiers', 'pyegg:pyegg', '')
classifiers = classifiers.split(',')
classifiers = [cla.strip() for cla in classifiers]
keywords = tgv.direct('keywords', 'pyegg:pyegg', '')
author = tgv.direct('author', 'pyegg:pyegg', '')
author_email = tgv.direct('email', 'pyegg:pyegg', '')
url = tgv.direct('url', 'pyegg:pyegg', '')
license_name = tgv.direct('license', 'pyegg:pyegg', '')
namespace = project.split('.')
namespace_packages = list()
if len(namespace) > 1:
for i in range(len(namespace) - 1):
namespace_packages.append('"%s"' % '.'.join(namespace[:i + 1]))
namespace_packages = ', '.join(namespace_packages)
zip_safe = tgv.direct('zipsafe', 'pyegg:pyegg', 'False')
if 'setup.py' in root:
setup = root['setup.py']
else:
setup = JinjaTemplate()
root['setup.py'] = setup
# read entry_points from token, so that other generators have the chance
# to define entry_points
entry_points_tok = token('entry_points', True, defs=[])
setup_dependencies = token('setup_dependencies', True, deps=[])
setup.template = templatepath('setup.py.jinja')
setup.params = {
'cp': cp,
'version': version,
'project': project,
'description': description,
'classifiers': classifiers,
'keywords': keywords,
'author': author,
'author_email': author_email,
'url': url,
'license_name': license_name,
'namespace_packages': namespace_packages,
'zip_safe': zip_safe,
'setup_dependencies': setup_dependencies.deps,
'entry_points':'\n'.join(entry_points_tok.defs),
}
# README.rst
if 'README.rst' not in root:
readme = JinjaTemplate()
root['README.rst'] = readme
readme.template = templatepath('README.rst.jinja')
readme.params = setup.params
# MANIFEST.rst
if 'MANIFEST.in' not in root:
manifest = JinjaTemplate()
root['MANIFEST.rst'] = manifest
manifest.template = templatepath('MANIFEST.in.jinja')
manifest.params = {}
# LICENSE.rst
if 'LICENSE.rst' not in root:
license = JinjaTemplate()
root['LICENSE.rst'] = license
license.template = templatepath('LICENSE.rst.jinja')
license.params = {}
