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 = {}