def test_commands_static_dump_errors(self):
from ptah.view.commands import StaticCommand
StaticCommand._include = ('ptah', self.__class__.__module__)
view.static('tests', 'ptah.view.tests:static/dir2')
_out = sys.stdout
file = os.path.join(self.dir, 'file')
f = open(file, 'w')
f.write(' ')
f.close()
sys.argv[:] = ['paste', 'static', '-d %s'%file]
out = StringIO()
sys.stdout = out
try:
run()
except SystemExit:
pass
sys.stdout = _out
val = out.getvalue()
self.assertTrue('Output path is not directory.' in val)
def test_post(self):
config = os.path.join('docs', 'example_app.ini')
url = '/'
with capture_stdout() as stdout:
if six.PY3:
stdout.buffer = io.BytesIO()
try:
command.run(['post', config, url])
except SystemExit as exc:
self.assertEqual(exc.code, 0)
else:
self.fail("SystemExit not raised")
if six.PY3:
out = stdout.buffer.getvalue()
out = out.decode('utf-8')
else:
out = stdout.getvalue()
html_regex = textwrap.dedent('''
<html>
<head>
<title>Test Application</title>
</head>
<body>
.*
</body>
</html>
''').strip()
html_regex = '\n%s\n' % html_regex
html_regex = re.compile(html_regex, re.DOTALL)
self.assertRegex(out, html_regex)
def create_product(self):
os.chdir(self.tmpdir)
pm = getToolByName(self.context, 'portal_membership')
member = pm.getAuthenticatedMember()
command = DistroCommand('create')
cmd = 'create -t %s %s --no-interactive' % (
self.type_generator.create_command, self.dotted_namespace)
args = cmd.split()
command.run(args[1:], {
'namespace_package': self.namespace_package,
'zope2product': True,
'description': '',
'author': member.getProperty('fullname', ''),
'author_email': member.getProperty('email', ''),
'license_name': 'GPL',
'package': self.contained_namespace_package,
'project': self.dotted_namespace,
'url': self.context.absolute_url(),
'version': self.request.get('package-version', '0.1'),
'zip_safe': False,
'keywords': '',
'title': self.request.get('project-title', self.dotted_namespace),
'egg': self.dotted_namespace,
'long_description': ''
})
os.chdir(self.product_location)
def test_help(self):
usage = textwrap.dedent('''
Usage: <test_command> [paster_options] COMMAND [command_options]
Options:
--version show program's version number and exit
--plugin=PLUGINS Add a plugin to the list of commands (plugins are Egg
specs; will also require() the Egg)
-h, --help Show this help message
Commands:
create Create the file layout for a Python distribution
grep Search project for symbol
help Display help
make-config Install a package and create a fresh config file/directory
points Show information about entry points
post Run a request for the described application
request Run a request for the described application
serve Serve the described application
setup-app Setup an application, given a config file
''').strip() + "\n\n"
with capture_stdout() as stdout:
argv = sys.argv
sys.argv = ['<test_command>', '--help']
try:
try:
command.run(['--help'])
except SystemExit as exc:
self.assertEqual(exc.code, 0)
else:
self.fail("SystemExit not raised")
finally:
sys.argv = argv
self.assertEqual(usage, stdout.getvalue())
def create_product(self):
os.chdir(self.tmpdir)
pm = getToolByName(self.context, 'portal_membership')
member = pm.getAuthenticatedMember()
command = DistroCommand('create')
cmd = 'create -t %s %s --no-interactive' % (
self.type_generator.create_command, self.dotted_namespace)
args = cmd.split()
command.run(
args[1:], {
'namespace_package': self.namespace_package,
'zope2product': True,
'description': '',
'author': member.getProperty('fullname', ''),
'author_email': member.getProperty('email', ''),
'license_name': 'GPL',
'package': self.contained_namespace_package,
'project': self.dotted_namespace,
'url': self.context.absolute_url(),
'version': self.request.get('package-version', '0.1'),
'zip_safe': False,
'keywords': '',
'title': self.request.get('project-title',
self.dotted_namespace),
'egg': self.dotted_namespace,
'long_description': ''
})
os.chdir(self.product_location)
def main():
"""
Simply calls 'paster create <opts>', defaulting to the pkglib_project template
"""
org.setup_global_org_config()
if not [i for i in sys.argv if i.startswith('-t')]:
sys.argv = sys.argv[:1] + ['-t', 'pkglib_project'] + sys.argv[1:]
sys.argv.insert(1, 'create')
run()
def main():
"""
Simply calls 'paster create <opts>', defaulting to the pkglib_project template
"""
org.setup_global_org_config()
if not [i for i in sys.argv if i.startswith('-t')]:
sys.argv = sys.argv[:1] + ['-t', 'pkglib_project'] + sys.argv[1:]
sys.argv.insert(1, 'create')
run()
def test_commands_static_dump(self):
view.static('tests', 'memphis.view.tests:static/dir2')
dir = os.path.join(self.dir, 'subdir')
sys.argv[:] = ['paste', 'static', '-d %s'%dir]
try:
run()
except SystemExit:
pass
val = self.out.getvalue()
self.assertTrue("* Coping from 'memphis.view.tests'" in val)
self.assertTrue(os.listdir(os.path.join(dir, 'tests')) ==
['text.txt', 'style.css'])
def command(self):
if self.args:
self.name = self.args[0]
while not self.name:
self.name = raw_input("Enter project name: ")
if not self.package:
package = self.name.lower()
package = beginning_letter.sub("", package)
package = valid_only.sub("", package)
while not self.package:
self.package = raw_input(
"Enter package name [%s]: " % package).strip() or package
self.name = pkg_resources.safe_name(self.name)
env = pkg_resources.Environment()
if self.name.lower() in env:
print 'The name "%s" is already in use by' % self.name,
for dist in env[self.name]:
print dist
return
import imp
try:
if imp.find_module(self.package):
print 'The package name "%s" is already in use' % self.package
return
except ImportError:
pass
if os.path.exists(self.name):
print 'A directory called "%s" already exists. Exiting.' % self.name
return
command = create_distro.CreateDistroCommand("create")
cmd_args = []
cmd_args.append("--template=quickstart-pluggable-template")
cmd_args.append(self.name)
cmd_args.append("package=%s" % self.package)
command.run(cmd_args)
os.chdir(self.name)
def paster(*args, **kwargs):
"""
Call a paster command.
All arguments are parsed and passed on to the command. The
``--config`` option is automatically appended.
By default, an ``AssertionError`` is raised if the command exits
with a non-zero return code or if anything is written to STDERR.
Pass ``fail_on_error=False`` to disable this behavior.
Example::
code, stdout, stderr = paster(u'jobs', u'list')
assert u'My Job Title' in stdout
code, stdout, stderr = paster(u'jobs', u'foobar',
fail_on_error=False)
assert code == 1
assert u'Unknown command' in stderr
Any ``SystemExit`` raised by the command is swallowed.
:returns: A tuple containing the return code, the content of
STDOUT, and the content of STDERR.
"""
fail_on_error = kwargs.pop(u"fail_on_error", True)
args = list(args) + [u"--config=" + config[u"__file__"]]
sys.stdout, sys.stderr = StringIO(u""), StringIO(u"")
code = 0
try:
run(args)
except SystemExit as e:
code = e.code
finally:
stdout, stderr = sys.stdout.getvalue(), sys.stderr.getvalue()
sys.stdout, sys.stderr = sys.__stdout__, sys.__stderr__
if code != 0 and fail_on_error:
raise AssertionError(
u"Paster command exited with non-zero return code {}: {}".format(
code, stderr))
if stderr.strip() and fail_on_error:
raise AssertionError(
u"Paster command wrote to STDERR: {}".format(stderr))
return code, stdout, stderr
def test_commands_static_dump_skipping_existing(self):
view.static('tests', 'memphis.view.tests:static/dir2')
os.makedirs(os.path.join(self.dir, 'tests'))
file = os.path.join(self.dir, 'tests', 'text.txt')
f = open(file, 'wb')
f.write('test existing file')
f.close()
sys.argv[:] = ['paste', 'static', '-d %s'%self.dir]
try:
run()
except SystemExit:
pass
val = self.out.getvalue()
self.assertTrue("skipping ../memphis.view.tests/text.txt" in val)
self.assertTrue('test existing file' == open(file, 'r').read())
def paster(*args, **kwargs):
'''
Call a paster command.
All arguments are parsed and passed on to the command. The
``--config`` option is automatically appended.
By default, an ``AssertionError`` is raised if the command exits
with a non-zero return code or if anything is written to STDERR.
Pass ``fail_on_error=False`` to disable this behavior.
Example::
code, stdout, stderr = paster(u'jobs', u'list')
assert u'My Job Title' in stdout
code, stdout, stderr = paster(u'jobs', u'foobar',
fail_on_error=False)
assert code == 1
assert u'Unknown command' in stderr
Any ``SystemExit`` raised by the command is swallowed.
:returns: A tuple containing the return code, the content of
STDOUT, and the content of STDERR.
'''
fail_on_error = kwargs.pop(u'fail_on_error', True)
args = list(args) + [u'--config=' + config[u'__file__']]
sys.stdout, sys.stderr = StringIO(u''), StringIO(u'')
code = 0
try:
run(args)
except SystemExit as e:
code = e.code
finally:
stdout, stderr = sys.stdout.getvalue(), sys.stderr.getvalue()
sys.stdout, sys.stderr = sys.__stdout__, sys.__stderr__
if code != 0 and fail_on_error:
raise AssertionError(u'Paster command exited with non-zero '
+ u'return code {}: {}'.format(code, stderr))
if stderr.strip() and fail_on_error:
raise AssertionError(u'Paster command wrote to STDERR: {}'.format(
stderr))
return code, stdout, stderr
def test_commands_static_dump(self):
view.static('tests', 'ptah.view.tests:static/dir2')
from ptah.view.commands import StaticCommand
StaticCommand._include = ('ptah', self.__class__.__module__)
dir = os.path.join(self.dir, 'subdir')
sys.argv[:] = ['paste', 'static', '-d %s'%dir]
try:
run()
except SystemExit:
pass
val = self.out.getvalue()
self.assertTrue("* Coping from 'ptah.view.tests'" in val)
files = os.listdir(os.path.join(dir, 'tests'))
files.sort()
self.assertTrue(files == ['style.css', 'text.txt'])
def test_commands_static_list(self):
view.static('tests', 'memphis.view.tests:static')
_out = sys.stdout
sys.argv[:] = ['paste', 'static', '-l']
out = StringIO()
sys.stdout = out
try:
print run()
except SystemExit:
pass
sys.stdout = _out
val = out.getvalue()
self.assertTrue('* tests' in val)
self.assertTrue('by: memphis.view.tests' in val)
def run_command(command, args):
"""Run paster command asynchronously"""
mod, cls = command.rsplit('.', 1)
mod = __import__(mod, fromlist=[str(cls)])
command = getattr(mod, cls)
command = command(command.__name__)
arg_list = shlex.split(args or '')
try:
command.parser.parse_args(arg_list)
except SystemExit:
raise Exception("Error parsing args: '%s'" % args)
return command.run(arg_list)
def test_commands_static_dump_skipping_existing(self):
from ptah.view.commands import StaticCommand
StaticCommand._include = ('ptah', self.__class__.__module__)
view.static('tests', 'ptah.view.tests:static/dir2')
os.makedirs(os.path.join(self.dir, 'tests'))
file = os.path.join(self.dir, 'tests', 'text.txt')
f = open(file, 'wb')
f.write('test existing file')
f.close()
sys.argv[:] = ['paste', 'static', '-d %s'%self.dir]
try:
run()
except SystemExit:
pass
val = self.out.getvalue()
self.assertTrue("skipping ../ptah.view.tests/text.txt" in val)
self.assertTrue('test existing file' == open(file, 'r').read())
def test_commands_static_dump_errors(self):
view.static('tests', 'memphis.view.tests:static/dir2')
_out = sys.stdout
file = os.path.join(self.dir, 'file')
f = open(file, 'w')
f.write(' ')
f.close()
sys.argv[:] = ['paste', 'static', '-d %s'%file]
out = StringIO()
sys.stdout = out
try:
run()
except SystemExit:
pass
sys.stdout = _out
val = out.getvalue()
self.assertTrue('Output path is not directory.' in val)
def _run(self):
try:
run()
except SystemExit:
pass
return self.out.getvalue()
def run(self):
from paste.script import command as pscmd
pscmd.run(["create", "-t", "simpleseer", self.options.projectname])
top level directly.
"""
import os, sys
# ensure supported version
from check_python import check_python
try:
check_python()
except:
sys.exit(1)
new_path = [os.path.join(os.getcwd(), "lib")]
new_path.extend(sys.path[1:]) # remove scripts/ from the path
sys.path = new_path
from galaxy import eggs
import pkg_resources
if 'LOG_TEMPFILES' in os.environ:
from log_tempfile import TempFile
_log_tempfile = TempFile()
import tempfile
pkg_resources.require("Paste")
pkg_resources.require("PasteScript")
pkg_resources.require("PasteDeploy")
from paste.script import command
command.run()
def command(self):
"""LayCement for the new project."""
self.__dict__.update(self.options.__dict__)
if self.args:
self.name = self.args[0]
while not self.name:
self.name = raw_input("Enter project name: ").strip()
self.name = pkg_resources.safe_name(self.name)
package = self.name.lower()
package = beginning_letter.sub("", package)
package = valid_only.sub("_", package)
self.package = raw_input(
"Enter module name [%s]: " % package).strip() or package
self.description = raw_input(
"Project Description: ").strip()
self.creator = raw_input(
"Project Creator: ").strip()
self.creator_email = raw_input(
"Project Creator Email: ").strip()
self.url = raw_input(
"Project URL: ").strip()
self.license = raw_input(
"Project License: ").strip()
env = pkg_resources.Environment()
if self.name.lower() in env:
print 'The name "%s" is already in use by ' % self.name,
for dist in env[self.name]:
print dist
return
import imp
try:
if imp.find_module(self.package):
print 'The package name "%s" is already in use' % self.package
return
except ImportError:
pass
if os.path.exists(self.name):
print 'A directory called "%s" already exists. Exiting.' % self.name
return
command = create_distro.CreateDistroCommand("create")
cmd_args = []
for template in self.templates.split():
cmd_args.append("--template=%s" % template)
cmd_args.append(self.name)
cmd_args.append("package=%s" % self.package)
cmd_args.append("cement_version=%s" % CEMENT_VERSION)
cmd_args.append("cement_next_version=%s" % CEMENT_NEXT_VERSION)
cmd_args.append("description=%s" % self.description)
cmd_args.append("creator=%s" % self.creator)
cmd_args.append("creator_email=%s" % self.creator_email)
cmd_args.append("url=%s" % self.url)
cmd_args.append("license=%s" % self.license)
command.run(cmd_args)
if not self.dry_run:
sys.argv = ["setup.py", "egg_info"]
# dirty hack to allow "empty" dirs
for base, path, files in os.walk("./"):
for file in files:
if file == "empty":
os.remove(os.path.join(base, file))
from paste.script.command import run
import shlex
run(shlex.split("serve app.ini"))
def command(self):
"""Quickstarts the new project."""
self.__dict__.update(self.options.__dict__)
if not True in [self.sqlalchemy, self.sqlobject]:
self.sqlalchemy = True
if self.args:
self.name = self.args[0]
while not self.name:
self.name = raw_input("Enter project name: ")
package = self.name.lower()
package = beginning_letter.sub("", package)
package = valid_only.sub("", package)
if package and self.no_input:
self.package = package
else:
self.package = None
while not self.package:
self.package = raw_input(
"Enter package name [%s]: " % package).strip() or package
if not self.no_input:
while self.auth is None:
self.auth = raw_input(
"Do you need authentication and authorization"
" in this project? [yes] ")
self.auth = dict(y=True,
n=False).get(self.auth.lstrip()[:1].lower()
or 'y')
if self.auth is None:
print "Please enter y(es) or n(o)."
if self.auth:
if self.sqlalchemy:
self.auth = "sqlalchemy"
else:
print(
'You can only use authentication and authorization'
' in a new project if you use SQLAlchemy. Please check'
' the repoze.what documentation to learn how to implement'
' authentication/authorization with other sources.')
return
# TODO: As far as I know, SQLObject has never been supported in
# TG2
# self.auth = "sqlobject"
else:
self.auth = None
self.name = pkg_resources.safe_name(self.name)
env = pkg_resources.Environment()
if self.name.lower() in env:
print 'The name "%s" is already in use by' % self.name,
for dist in env[self.name]:
print dist
return
import imp
try:
if imp.find_module(self.package):
print 'The package name "%s" is already in use' % self.package
return
except ImportError:
pass
if os.path.exists(self.name):
print 'A directory called "%s" already exists. Exiting.' % self.name
return
command = create_distro.CreateDistroCommand("create")
cmd_args = []
for template in self.templates.split():
cmd_args.append("--template=%s" % template)
if self.svn_repository:
cmd_args.append("--svn-repository=%s" % self.svn_repository)
if self.dry_run:
cmd_args.append("--simulate")
cmd_args.append("-q")
cmd_args.append(self.name)
cmd_args.append("sqlalchemy=%s" % self.sqlalchemy)
cmd_args.append("sqlobject=%s" % self.sqlobject)
cmd_args.append("auth=%s" % self.auth)
cmd_args.append("geo=%s" % self.geo)
cmd_args.append("package=%s" % self.package)
cmd_args.append("tgversion=%s" % self.version)
# set the exact ORM-version for the proper requirements
# it's extracted from our own requirements, so looking
# them up must be in sync (there must be the extras_require named
# sqlobject/sqlalchemy)
"""if self.sqlobject:
sqlobjectversion = str(get_requirement('sqlobject'))
cmd_args.append("sqlobjectversion=%s" % sqlobjectversion)
if self.sqlalchemy:
sqlalchemyversion = str(get_requirement('sqlalchemy'))
cmd_args.append("sqlalchemyversion=%s" % sqlalchemyversion)
"""
command.run(cmd_args)
if not self.dry_run:
os.chdir(self.name)
if self.sqlobject:
# Create the SQLObject history directory only when needed.
# With paste.script it's only possible to skip files, but
# not directories. So we are handling this manually.
sodir = '%s/sqlobject-history' % self.package
if not os.path.exists(sodir):
os.mkdir(sodir)
try:
if not os.path.exists(
os.path.join(
os.path.dirname(os.path.abspath(sodir)),
'.svn')):
raise OSError
command.run_command('svn', 'add', sodir)
except OSError:
pass
startscript = "start-%s.py" % self.package
if os.path.exists(startscript):
oldmode = os.stat(startscript).st_mode
os.chmod(startscript, oldmode | stat.S_IXUSR)
sys.argv = ["setup.py", "egg_info"]
import imp
imp.load_module("setup", *imp.find_module("setup", ["."]))
# dirty hack to allow "empty" dirs
for base, path, files in os.walk("./"):
for file in files:
if file == "empty":
os.remove(os.path.join(base, file))
def command(self):
"""Quickstarts the new project."""
self.__dict__.update(self.options.__dict__)
if self.args:
self.name = self.args[0]
while not self.name:
self.name = raw_input("Enter project name: ")
package = self.name.lower()
package = beginning_letter.sub("", package)
package = valid_only.sub("", package)
if package:
self.package = package
else:
self.package = None
while not self.package:
self.package = raw_input(
"Enter package name [%s]: " % package).strip() or package
self.name = pkg_resources.safe_name(self.name).replace('-', '_')
self.rpm_name = self.package.replace('.', '-')
env = pkg_resources.Environment()
if self.name.lower() in env:
print 'The name "%s" is already in use by' % self.name,
for dist in env[self.name]:
print dist
return
try:
if imp.find_module(self.package):
print 'The package name "%s" is already in use' % self.package
return
except ImportError:
pass
if os.path.exists(self.name):
print 'A directory called "%s" already exists. Exiting.' % self.name
return
command = create_distro.CreateDistroCommand("create")
cmd_args = ['--template=moksha.master']
if self.livewidget:
cmd_args.append('--template=moksha.livewidget')
if self.stream:
cmd_args.append('--template=moksha.stream')
if self.consumer:
cmd_args.append('--template=moksha.consumer')
if self.controller:
cmd_args.append('--template=moksha.controller')
#if self.dry_run:
# cmd_args.append("--simulate")
# cmd_args.append("-q")
cmd_args.append(self.name)
cmd_args.append("livewidget=%s" % self.livewidget)
cmd_args.append("consumer=%s" % self.consumer)
cmd_args.append("controller=%s" % self.controller)
cmd_args.append("stream=%s" % self.stream)
cmd_args.append("package=%s" % self.package)
cmd_args.append("widget_name=%s" % self.package.title() + 'Widget')
cmd_args.append("stream_name=%s" % self.package.title() + 'Stream')
cmd_args.append("consumer_name=%s" % self.package.title() + 'Consumer')
cmd_args.append("controller_name=%s" % self.package.title() + 'Controller')
command.run(cmd_args)
#!/usr/bin/env python
import os
import sys
try:
here = __file__
except NameError:
# Python 2.2
here = sys.argv[0]
relative_paste = os.path.join(
os.path.dirname(os.path.dirname(os.path.abspath(here))), 'paste')
if os.path.exists(relative_paste):
sys.path.insert(0, os.path.dirname(relative_paste))
from paste.script import command
command.run()
def deploy_zope_app():
extra_args = sys.argv[1:]
command.run(['create', '-t', 'deploy_zope_app'] + extra_args)
def make_zope_app():
extra_args = sys.argv[1:]
command.run(['create', '-t', 'make_zope_app'] + extra_args)
def paster(args):
try:
run(args.split(' '))
except SystemExit:
pass
def paster(args):
try:
run(args.split(' '))
except SystemExit:
pass
def command(self):
"""Quickstarts the new project."""
self.__dict__.update(self.options.__dict__)
if not True in [self.elixir, self.sqlalchemy, self.sqlobject]:
self.sqlalchemy = True
if self.elixir:
self.sqlalchemy = True
if self.args:
self.name = self.args[0]
while not self.name:
self.name = raw_input("Enter project name: ")
while not self.package:
package = self.name.lower()
package = beginning_letter.sub("", package)
package = valid_only.sub("", package)
self.package = raw_input("Enter package name [%s]: " % package)
if not self.package:
self.package = package
doidentity = self.identity
while not doidentity:
doidentity = raw_input("Do you need Identity " "(usernames/passwords) in this project? [no] ")
doidentity = doidentity.lower()
if not doidentity or doidentity.startswith("n"):
self.identity = False
break
if doidentity.startswith("y"):
doidentity = True
break
print "Please enter y(es) or n(o)."
doidentity = None
if doidentity is True:
if self.sqlalchemy:
self.identity = "sqlalchemy"
else:
self.identity = "sqlobject"
self.name = pkg_resources.safe_name(self.name)
env = pkg_resources.Environment()
if self.name.lower() in env:
print 'The name "%s" is already in use by' % self.name,
for dist in env[self.name]:
print dist
return
import imp
try:
if imp.find_module(self.package):
print 'The package name "%s" is already in use' % self.package
return
except ImportError:
pass
if os.path.exists(self.name):
print 'A directory called "%s" already exists. Exiting.' % self.name
return
command = create_distro.CreateDistroCommand("create")
cmd_args = []
for template in self.templates.split(" "):
cmd_args.append("--template=%s" % template)
if self.svn_repository:
cmd_args.append("--svn-repository=%s" % self.svn_repository)
if self.dry_run:
cmd_args.append("--simulate")
cmd_args.append("-q")
cmd_args.append(self.name)
cmd_args.append("sqlalchemy=%s" % self.sqlalchemy)
cmd_args.append("elixir=%s" % self.elixir)
cmd_args.append("sqlobject=%s" % self.sqlobject)
cmd_args.append("identity=%s" % self.identity)
cmd_args.append("package=%s" % self.package)
cmd_args.append("tgversion=%s" % self.version)
# set the exact ORM-version for the proper requirements
# it's extracted from our own requirements, so looking
# them up must be in sync (there must be the extras_require named
# sqlobject/sqlalchemy)
"""if self.sqlobject:
sqlobjectversion = str(get_requirement('sqlobject'))
cmd_args.append("sqlobjectversion=%s" % sqlobjectversion)
if self.sqlalchemy:
sqlalchemyversion = str(get_requirement('sqlalchemy'))
cmd_args.append("sqlalchemyversion=%s" % sqlalchemyversion)
if self.elixir:
elixirversion = str(get_requirement('future', 'elixir'))
cmd_args.append("elixirversion=%s" % elixirversion)
"""
command.run(cmd_args)
if not self.dry_run:
os.chdir(self.name)
if self.sqlobject:
# Create the SQLObject history directory only when needed.
# With paste.script it's only possible to skip files, but
# not directories. So we are handling this manually.
sodir = "%s/sqlobject-history" % self.package
if not os.path.exists(sodir):
os.mkdir(sodir)
try:
if not os.path.exists(os.path.join(os.path.dirname(os.path.abspath(sodir)), ".svn")):
raise OSError
command.run_command("svn", "add", sodir)
except OSError:
pass
startscript = "start-%s.py" % self.package
if os.path.exists(startscript):
oldmode = os.stat(startscript).st_mode
os.chmod(startscript, oldmode | stat.S_IXUSR)
sys.argv = ["setup.py", "egg_info"]
import imp
imp.load_module("setup", *imp.find_module("setup", ["."]))
# dirty hack to allow "empty" dirs
for base, path, files in os.walk("./"):
for file in files:
if file == "empty":
os.remove(os.path.join(base, file))
def command(self):
"""Quickstarts the new project."""
self.__dict__.update(self.options.__dict__)
if not self.sqlalchemy and not self.sqlobject:
self.sqlalchemy = True
if self.args:
self.name = self.args[0]
while not self.name:
self.name = raw_input("Enter project name: ")
package = self.name.lower()
package = beginning_letter.sub("", package)
package = valid_only.sub("", package)
if package and self.no_input:
self.package = package
else:
self.package = None
while not self.package:
self.package = raw_input(
"Enter package name [%s]: " % package).strip() or package
if self.no_input:
self.mako = False
self.auth = True
else:
while self.mako is None:
self.mako = raw_input(
"Would you prefer mako templates? (yes/[no]): ")
self.mako = dict(y=True, n=False).get(
self.mako.lstrip()[:1].lower() or 'n')
if self.mako is None:
print "Please enter y(es) or n(o)."
while self.auth is None:
self.auth = raw_input(
"Do you need authentication and authorization"
" in this project? ([yes]/no): ")
self.auth = dict(y=True, n=False).get(
self.auth.lstrip()[:1].lower() or 'y')
if self.auth is None:
print "Please enter y(es) or n(o)."
if self.auth:
if self.sqlalchemy:
self.auth = "sqlalchemy"
else:
print ('You can only use authentication and authorization'
' in a new project if you use SQLAlchemy. Please check'
' the repoze.what documentation to learn how to implement'
' authentication/authorization with other sources.')
return
# TODO: As far as I know, SQLObject has never been supported in
# TG2
# self.auth = "sqlobject"
else:
self.auth = None
self.name = pkg_resources.safe_name(self.name)
env = pkg_resources.Environment()
if self.name.lower() in env:
print 'The name "%s" is already in use by' % self.name,
for dist in env[self.name]:
print dist
return
import imp
try:
if imp.find_module(self.package):
print 'The package name "%s" is already in use' % self.package
return
except ImportError:
pass
if os.path.exists(self.name):
print 'A directory called "%s" already exists. Exiting.' % self.name
return
self.cookiesecret = None
try:
import uuid
self.cookiesecret = str(uuid.uuid4())
except ImportError:
import random
import base64
import struct
self.cookiesecret = base64.b64encode("".join([struct.pack('i', random.randrange(2**31)) for x in [1,2,3,4,5,6]])).strip()
command = create_distro.CreateDistroCommand("create")
cmd_args = []
for template in self.templates.split():
cmd_args.append("--template=%s" % template)
if self.svn_repository:
cmd_args.append("--svn-repository=%s" % self.svn_repository)
if self.dry_run:
cmd_args.append("--simulate")
cmd_args.append("-q")
cmd_args.append(self.name)
cmd_args.append("sqlalchemy=%s" % self.sqlalchemy)
cmd_args.append("sqlobject=%s" % self.sqlobject)
cmd_args.append("auth=%s" % self.auth)
cmd_args.append("geo=%s" % self.geo)
cmd_args.append("package=%s" % self.package)
cmd_args.append("tgversion=%s" % self.version)
cmd_args.append("mako=%s"%self.mako)
cmd_args.append("cookiesecret=%s"%self.cookiesecret)
# set the exact ORM-version for the proper requirements
# it's extracted from our own requirements, so looking
# them up must be in sync (there must be the extras_require named
# sqlobject/sqlalchemy)
"""if self.sqlobject:
sqlobjectversion = str(get_requirement('sqlobject'))
cmd_args.append("sqlobjectversion=%s" % sqlobjectversion)
if self.sqlalchemy:
sqlalchemyversion = str(get_requirement('sqlalchemy'))
cmd_args.append("sqlalchemyversion=%s" % sqlalchemyversion)
"""
command.run(cmd_args)
if not self.dry_run:
os.chdir(self.name)
if self.sqlobject:
# Create the SQLObject history directory only when needed.
# With paste.script it's only possible to skip files, but
# not directories. So we are handling this manually.
sodir = '%s/sqlobject-history' % self.package
if not os.path.exists(sodir):
os.mkdir(sodir)
try:
if not os.path.exists(os.path.join(os.path.dirname(
os.path.abspath(sodir)), '.svn')):
raise OSError
command.run_command('svn', 'add', sodir)
except OSError:
pass
startscript = "start-%s.py" % self.package
if os.path.exists(startscript):
oldmode = os.stat(startscript).st_mode
os.chmod(startscript,
oldmode | stat.S_IXUSR)
sys.argv = ["setup.py", "egg_info"]
import imp
imp.load_module("setup", *imp.find_module("setup", ["."]))
# dirty hack to allow "empty" dirs
for base, path, files in os.walk("./"):
for file in files:
if file == "empty":
os.remove(os.path.join(base, file))
if self.mako:
print 'Writing mako template files to ./'+os.path.join(self.package, 'templates')
#remove existing template files
package_template_dir = os.path.abspath(os.path.join(self.package, 'templates'))
shutil.rmtree(package_template_dir, ignore_errors=True)
# os.mkdir(package_template_dir)
#replace template files with mako ones
mako_template_dir = os.path.abspath(os.path.dirname(__file__))+'/quickstart_mako'
shutil.copytree(mako_template_dir, package_template_dir)
def command(self):
"""LayCement for the new project."""
self.__dict__.update(self.options.__dict__)
if self.args:
self.name = self.args[0]
while not self.name:
self.name = raw_input("Enter project name: ").strip()
self.name = pkg_resources.safe_name(self.name)
package = self.name.lower()
package = beginning_letter.sub("", package)
package = valid_only.sub("_", package)
self.package = raw_input(
"Enter module name [%s]: " % package).strip() or package
self.description = raw_input("Project Description: ").strip()
self.creator = raw_input("Project Creator: ").strip()
self.creator_email = raw_input("Project Creator Email: ").strip()
self.url = raw_input("Project URL: ").strip()
self.license = raw_input("Project License: ").strip()
env = pkg_resources.Environment()
if self.name.lower() in env:
print 'The name "%s" is already in use by ' % self.name,
for dist in env[self.name]:
print dist
return
import imp
try:
if imp.find_module(self.package):
print 'The package name "%s" is already in use' % self.package
return
except ImportError:
pass
if os.path.exists(self.name):
print 'A directory called "%s" already exists. Exiting.' % self.name
return
command = create_distro.CreateDistroCommand("create")
cmd_args = []
for template in self.templates.split():
cmd_args.append("--template=%s" % template)
cmd_args.append(self.name)
cmd_args.append("package=%s" % self.package)
cmd_args.append("cement_version=%s" % CEMENT_VERSION)
cmd_args.append("cement_next_version=%s" % CEMENT_NEXT_VERSION)
cmd_args.append("description=%s" % self.description)
cmd_args.append("creator=%s" % self.creator)
cmd_args.append("creator_email=%s" % self.creator_email)
cmd_args.append("url=%s" % self.url)
cmd_args.append("license=%s" % self.license)
command.run(cmd_args)
if not self.dry_run:
sys.argv = ["setup.py", "egg_info"]
# dirty hack to allow "empty" dirs
for base, path, files in os.walk("./"):
for file in files:
if file == "empty":
os.remove(os.path.join(base, file))
def command(self):
"""Quickstarts the new project."""
self.__dict__.update(self.options.__dict__)
if self.args:
self.name = self.args[0]
while not self.name:
self.name = raw_input("Enter project name: ")
package = self.name.lower()
package = beginning_letter.sub("", package)
package = valid_only.sub("", package)
if package:
self.package = package
else:
self.package = None
while not self.package:
self.package = raw_input(
"Enter package name [%s]: " % package).strip() or package
self.name = pkg_resources.safe_name(self.name).replace('-', '_')
self.rpm_name = self.package.replace('.', '-')
env = pkg_resources.Environment()
if self.name.lower() in env:
print 'The name "%s" is already in use by' % self.name,
for dist in env[self.name]:
print dist
return
try:
if imp.find_module(self.package):
print 'The package name "%s" is already in use' % self.package
return
except ImportError:
pass
if os.path.exists(self.name):
print 'A directory called "%s" already exists. Exiting.' % self.name
return
command = create_distro.CreateDistroCommand("create")
cmd_args = ['--template=moksha.master']
if self.livewidget:
cmd_args.append('--template=moksha.livewidget')
if self.stream:
cmd_args.append('--template=moksha.stream')
if self.consumer:
cmd_args.append('--template=moksha.consumer')
if self.connector:
cmd_args.append('--template=moksha.connector')
if self.controller:
cmd_args.append('--template=moksha.controller')
#if self.dry_run:
# cmd_args.append("--simulate")
# cmd_args.append("-q")
cmd_args.append(self.name)
cmd_args.append("livewidget=%s" % self.livewidget)
cmd_args.append("connector=%s" % self.connector)
cmd_args.append("consumer=%s" % self.consumer)
cmd_args.append("controller=%s" % self.controller)
cmd_args.append("stream=%s" % self.stream)
cmd_args.append("package=%s" % self.package)
cmd_args.append("widget_name=%s" % self.package.title() + 'Widget')
cmd_args.append("stream_name=%s" % self.package.title() + 'Stream')
cmd_args.append("consumer_name=%s" % self.package.title() + 'Consumer')
cmd_args.append("connector_name=%s" % self.package.title() +
'Connector')
cmd_args.append("controller_name=%s" % self.package.title() +
'Controller')
command.run(cmd_args)
def command(self):
"""Quickstarts the new project."""
self.__dict__.update(self.options.__dict__)
if self.no_sqlalchemy:
self.sqlalchemy = False
if self.ming:
self.sqlalchemy = False
self.migrations = False
if self.no_auth:
self.auth=False
if self.args:
self.name = self.args[0]
while not self.name:
self.name = raw_input("Enter project name: ")
if not self.package:
package = self.name.lower()
package = beginning_letter.sub("", package)
package = valid_only.sub("", package)
if package and self.no_input:
self.package = package
else:
self.package = None
while not self.package:
self.package = raw_input(
"Enter package name [%s]: " % package).strip() or package
if self.no_input:
#defaults
self.mako = False
self.auth = True
while self.mako is None:
self.mako = raw_input(
"Would you prefer mako templates? (yes/[no]): ")
self.mako = dict(y=True, n=False).get(
self.mako.lstrip()[:1].lower() or 'n')
if self.mako is None:
print "Please enter y(es) or n(o)."
while self.auth is None:
self.auth = raw_input(
"Do you need authentication and authorization"
" in this project? ([yes]/no): ")
self.auth = dict(y=True, n=False).get(
self.auth.lstrip()[:1].lower() or 'y')
if self.auth is None:
print "Please enter y(es) or n(o)."
if self.auth:
if self.ming:
self.auth = "ming"
self.ming = True
else:
self.auth = "sqlalchemy"
self.sqlalchemy = True
else:
self.auth = None
self.name = pkg_resources.safe_name(self.name)
env = pkg_resources.Environment()
if self.name.lower() in env:
print 'The name "%s" is already in use by' % self.name,
for dist in env[self.name]:
print dist
return
import imp
try:
if imp.find_module(self.package):
print 'The package name "%s" is already in use' % self.package
return
except ImportError:
pass
if os.path.exists(self.name):
print 'A directory called "%s" already exists. Exiting.' % self.name
return
self.cookiesecret = None
try:
import uuid
self.cookiesecret = str(uuid.uuid4())
except ImportError:
import random
import base64
import struct
self.cookiesecret = base64.b64encode("".join([struct.pack('i', random.randrange(2**31)) for x in [1,2,3,4,5,6]])).strip()
command = create_distro.CreateDistroCommand("create")
cmd_args = []
templates = self.templates.split()
if self.minimal:
templates = ['turbogears2-minimal']
for template in templates:
cmd_args.append("--template=%s" % template)
if self.dry_run:
cmd_args.append("--simulate")
cmd_args.append("-q")
cmd_args.append(self.name)
cmd_args.append("sqlalchemy=%s" % self.sqlalchemy)
cmd_args.append("ming=%s" % self.ming)
cmd_args.append("auth=%s" % self.auth)
cmd_args.append("geo=%s" % self.geo)
cmd_args.append("package=%s" % self.package)
cmd_args.append("tgversion=%s" % self.version)
cmd_args.append("mako=%s"%self.mako)
cmd_args.append("migrations=%s"%self.migrations)
cmd_args.append("cookiesecret=%s"%self.cookiesecret)
# set the exact ORM-version for the proper requirements
# it's extracted from our own requirements, so looking
# them up must be in sync (there must be the extras_require named
# sqlalchemy)
command.run(cmd_args)
if self.dry_run:
return
os.chdir(self.name)
sys.argv = ["setup.py", "egg_info"]
import imp
imp.load_module("setup", *imp.find_module("setup", ["."]))
# dirty hack to allow "empty" dirs
for base, path, files in os.walk("./"):
for file in files:
if file == "empty":
os.remove(os.path.join(base, file))
#copy over the mako templates if appropriate
if self.mako:
print 'Writing mako template files to ./'+os.path.join(self.package, 'templates')
#remove existing template files
package_template_dir = os.path.abspath(os.path.join(self.package, 'templates'))
shutil.rmtree(package_template_dir, ignore_errors=True)
#replace template files with mako ones
mako_template_dir = os.path.abspath(os.path.dirname(__file__))+'/quickstart_mako'
shutil.copytree(mako_template_dir, package_template_dir)
if self.ming:
print 'Writing Ming model files to ./'+os.path.join(self.package, 'model')
package_model_dir = os.path.abspath(os.path.join(self.package, 'model'))
ming_model_dir = os.path.abspath(os.path.dirname(__file__))+'/model_ming'
shutil.copy(os.path.join(ming_model_dir, 'session.py'), package_model_dir)
if not self.migrations:
print 'Disabling migrations support'
#remove existing migrations directory
package_migrations_dir = os.path.abspath('migration')
shutil.rmtree(package_migrations_dir, ignore_errors=True)
def command(self):
"""Quickstarts the new project."""
self.__dict__.update(self.options.__dict__)
if self.no_sqlalchemy:
self.sqlalchemy = False
if self.ming:
self.sqlalchemy = False
self.migrations = False
if self.no_auth:
self.auth = False
if self.args:
self.name = self.args[0]
while not self.name:
self.name = raw_input("Enter project name: ")
if not self.package:
package = self.name.lower()
package = beginning_letter.sub("", package)
package = valid_only.sub("", package)
if package and self.no_input:
self.package = package
else:
self.package = None
while not self.package:
self.package = raw_input("Enter package name [%s]: " %
package).strip() or package
if self.no_input:
#defaults
self.mako = False
self.jinja = False
self.kajiki = False
self.auth = True
if self.jinja is None and self.mako is None and self.kajiki is None:
template = None
while template is None:
template = raw_input(
"Would you prefer to use an alternative template system? (m=mako, j=jinja, k=kajiki, n=no [default]): "
)
template = dict(m="mako", j="jinja", k='kajiki',
n="none").get(template.lstrip()[:1].lower()
or 'n')
if template == "mako":
self.mako = True
elif template == "jinja":
self.jinja = True
elif template == "kajiki":
self.kajiki = True
elif template is None:
print "Please enter an option or n(o)."
while self.auth is None:
self.auth = raw_input(
"Do you need authentication and authorization"
" in this project? ([yes]/no): ")
self.auth = dict(y=True,
n=False).get(self.auth.lstrip()[:1].lower()
or 'y')
if self.auth is None:
print "Please enter y(es) or n(o)."
if self.auth:
if self.ming:
self.auth = "ming"
self.ming = True
else:
self.auth = "sqlalchemy"
self.sqlalchemy = True
else:
self.auth = None
self.name = pkg_resources.safe_name(self.name)
env = pkg_resources.Environment()
if self.name.lower() in env:
print 'The name "%s" is already in use by' % self.name,
for dist in env[self.name]:
print dist
return
import imp
try:
if imp.find_module(self.package):
print 'The package name "%s" is already in use' % self.package
return
except ImportError:
pass
if os.path.exists(self.name):
print 'A directory called "%s" already exists. Exiting.' % self.name
return
self.cookiesecret = None
try:
import uuid
self.cookiesecret = str(uuid.uuid4())
except ImportError:
import random
import base64
import struct
self.cookiesecret = base64.b64encode("".join([
struct.pack('i', random.randrange(2**31))
for x in [1, 2, 3, 4, 5, 6]
])).strip()
command = create_distro.CreateDistroCommand("create")
cmd_args = []
templates = self.templates.split()
for template in templates:
cmd_args.append("--template=%s" % template)
if self.dry_run:
cmd_args.append("--simulate")
cmd_args.append("-q")
cmd_args.append(self.name)
cmd_args.append("sqlalchemy=%s" % self.sqlalchemy)
cmd_args.append("ming=%s" % self.ming)
cmd_args.append("auth=%s" % self.auth)
cmd_args.append("geo=%s" % self.geo)
cmd_args.append("tw1=%s" % self.tw1)
cmd_args.append("package=%s" % self.package)
cmd_args.append("tgversion=%s" % self.version)
cmd_args.append("mako=%s" % self.mako)
cmd_args.append("jinja=%s" % self.jinja)
cmd_args.append("kajiki=%s" % self.kajiki)
cmd_args.append("migrations=%s" % self.migrations)
cmd_args.append("cookiesecret=%s" % self.cookiesecret)
# set the exact ORM-version for the proper requirements
# it's extracted from our own requirements, so looking
# them up must be in sync (there must be the extras_require named
# sqlalchemy)
command.run(cmd_args)
if self.dry_run:
return
os.chdir(self.name)
sys.argv = ["setup.py", "egg_info"]
import imp
imp.load_module("setup", *imp.find_module("setup", ["."]))
# dirty hack to allow "empty" dirs
for base, path, files in os.walk("./"):
for file in files:
if file == "empty":
os.remove(os.path.join(base, file))
#copy over the alternative templates if appropriate
if self.mako or self.kajiki or self.jinja:
def overwrite_templates(template_type):
print 'Writing ' + template_type + ' template files to ./' + os.path.join(
self.package, 'templates')
#remove existing template files
package_template_dir = os.path.abspath(
os.path.join(self.package, 'templates'))
shutil.rmtree(package_template_dir, ignore_errors=True)
#replace template files with alternative ones
alt_template_dir = os.path.abspath(
os.path.dirname(__file__)) + '/quickstart_' + template_type
shutil.copytree(alt_template_dir, package_template_dir)
if self.mako:
overwrite_templates('mako')
elif self.jinja:
overwrite_templates('jinja')
elif self.kajiki:
overwrite_templates('kajiki')
if self.ming:
print 'Writing Ming model files to ./' + os.path.join(
self.package, 'model')
package_model_dir = os.path.abspath(
os.path.join(self.package, 'model'))
ming_model_dir = os.path.abspath(
os.path.dirname(__file__)) + '/model_ming'
shutil.copy(os.path.join(ming_model_dir, 'session.py'),
package_model_dir)
if not self.migrations:
print 'Disabling migrations support'
#remove existing migrations directory
package_migrations_dir = os.path.abspath('migration')
shutil.rmtree(package_migrations_dir, ignore_errors=True)
