# (c) 2005 Ian Bicking and contributors; written for Paste
|
# (http://pythonpaste.org) Licensed under the MIT license:
|
# http://www.opensource.org/licenses/mit-license.php
|
|
import argparse
|
import os
|
import os.path
|
import pkg_resources
|
import re
|
import sys
|
from pyramid.compat import input_
|
|
_bad_chars_re = re.compile('[^a-zA-Z0-9_]')
|
|
|
def main(argv=sys.argv, quiet=False):
|
command = PCreateCommand(argv, quiet)
|
try:
|
return command.run()
|
except KeyboardInterrupt: # pragma: no cover
|
return 1
|
|
|
class PCreateCommand(object):
|
verbosity = 1 # required
|
parser = argparse.ArgumentParser(
|
description="""\
|
Render Pyramid scaffolding to an output directory.
|
|
Note: As of Pyramid 1.8, this command is deprecated. Use
|
pyramid-cookiecutter-starter instead:
|
https://github.com/Pylons/pyramid-cookiecutter-starter
|
""",
|
formatter_class=argparse.RawDescriptionHelpFormatter,
|
)
|
parser.add_argument(
|
'-s',
|
'--scaffold',
|
dest='scaffold_name',
|
action='append',
|
help=(
|
"Add a scaffold to the create process "
|
"(multiple -s args accepted)"
|
),
|
)
|
parser.add_argument(
|
'-t',
|
'--template',
|
dest='scaffold_name',
|
action='append',
|
help=(
|
'A backwards compatibility alias for '
|
'-s/--scaffold. Add a scaffold to the '
|
'create process (multiple -t args accepted)'
|
),
|
)
|
parser.add_argument(
|
'-l',
|
'--list',
|
dest='list',
|
action='store_true',
|
help="List all available scaffold names",
|
)
|
parser.add_argument(
|
'--list-templates',
|
dest='list',
|
action='store_true',
|
help=(
|
"A backwards compatibility alias for -l/--list. "
|
"List all available scaffold names."
|
),
|
)
|
parser.add_argument(
|
'--package-name',
|
dest='package_name',
|
action='store',
|
help='Package name to use. The name provided is '
|
'assumed to be a valid Python package name, and '
|
'will not be validated. By default the package '
|
'name is derived from the value of '
|
'output_directory.',
|
)
|
parser.add_argument(
|
'--simulate',
|
dest='simulate',
|
action='store_true',
|
help='Simulate but do no work',
|
)
|
parser.add_argument(
|
'--overwrite',
|
dest='overwrite',
|
action='store_true',
|
help='Always overwrite',
|
)
|
parser.add_argument(
|
'--interactive',
|
dest='interactive',
|
action='store_true',
|
help='When a file would be overwritten, interrogate '
|
'(this is the default, but you may specify it to '
|
'override --overwrite)',
|
)
|
parser.add_argument(
|
'--ignore-conflicting-name',
|
dest='force_bad_name',
|
action='store_true',
|
default=False,
|
help='Do create a project even if the chosen name '
|
'is the name of an already existing / importable '
|
'package.',
|
)
|
parser.add_argument(
|
'output_directory',
|
nargs='?',
|
default=None,
|
help='The directory where the project will be ' 'created.',
|
)
|
|
pyramid_dist = pkg_resources.get_distribution("pyramid")
|
|
def __init__(self, argv, quiet=False):
|
self.quiet = quiet
|
self.args = self.parser.parse_args(argv[1:])
|
if not self.args.interactive and not self.args.overwrite:
|
self.args.interactive = True
|
self.scaffolds = self.all_scaffolds()
|
|
def run(self):
|
if self.args.list:
|
return self.show_scaffolds()
|
if not self.args.scaffold_name and not self.args.output_directory:
|
if not self.quiet: # pragma: no cover
|
self.parser.print_help()
|
self.out('')
|
self.show_scaffolds()
|
return 2
|
|
if not self.validate_input():
|
return 2
|
self._warn_pcreate_deprecated()
|
|
return self.render_scaffolds()
|
|
@property
|
def output_path(self):
|
return os.path.abspath(os.path.normpath(self.args.output_directory))
|
|
@property
|
def project_vars(self):
|
output_dir = self.output_path
|
project_name = os.path.basename(os.path.split(output_dir)[1])
|
if self.args.package_name is None:
|
pkg_name = _bad_chars_re.sub(
|
'', project_name.lower().replace('-', '_')
|
)
|
safe_name = pkg_resources.safe_name(project_name)
|
else:
|
pkg_name = self.args.package_name
|
safe_name = pkg_name
|
egg_name = pkg_resources.to_filename(safe_name)
|
|
# get pyramid package version
|
pyramid_version = self.pyramid_dist.version
|
|
# map pyramid package version of the documentation branch ##
|
# if version ends with 'dev' then docs version is 'master'
|
if self.pyramid_dist.version[-3:] == 'dev':
|
pyramid_docs_branch = 'master'
|
else:
|
# if not version is not 'dev' find the version.major_version string
|
# and combine it with '-branch'
|
version_match = re.match(r'(\d+\.\d+)', self.pyramid_dist.version)
|
if version_match is not None:
|
pyramid_docs_branch = "%s-branch" % version_match.group()
|
# if can not parse the version then default to 'latest'
|
else:
|
pyramid_docs_branch = 'latest'
|
|
return {
|
'project': project_name,
|
'package': pkg_name,
|
'egg': egg_name,
|
'pyramid_version': pyramid_version,
|
'pyramid_docs_branch': pyramid_docs_branch,
|
}
|
|
def render_scaffolds(self):
|
props = self.project_vars
|
output_dir = self.output_path
|
for scaffold_name in self.args.scaffold_name:
|
for scaffold in self.scaffolds:
|
if scaffold.name == scaffold_name:
|
scaffold.run(self, output_dir, props)
|
return 0
|
|
def show_scaffolds(self):
|
scaffolds = sorted(self.scaffolds, key=lambda x: x.name)
|
if scaffolds:
|
max_name = max([len(t.name) for t in scaffolds])
|
self.out('Available scaffolds:')
|
for scaffold in scaffolds:
|
self.out(
|
' %s:%s %s'
|
% (
|
scaffold.name,
|
' ' * (max_name - len(scaffold.name)),
|
scaffold.summary,
|
)
|
)
|
else:
|
self.out('No scaffolds available')
|
return 0
|
|
def all_scaffolds(self):
|
scaffolds = []
|
eps = list(pkg_resources.iter_entry_points('pyramid.scaffold'))
|
for entry in eps:
|
try:
|
scaffold_class = entry.load()
|
scaffold = scaffold_class(entry.name)
|
scaffolds.append(scaffold)
|
except Exception as e: # pragma: no cover
|
self.out(
|
'Warning: could not load entry point %s (%s: %s)'
|
% (entry.name, e.__class__.__name__, e)
|
)
|
return scaffolds
|
|
def out(self, msg): # pragma: no cover
|
if not self.quiet:
|
print(msg)
|
|
def validate_input(self):
|
if not self.args.scaffold_name:
|
self.out(
|
'You must provide at least one scaffold name: '
|
'-s <scaffold name>'
|
)
|
self.out('')
|
self.show_scaffolds()
|
return False
|
if not self.args.output_directory:
|
self.out('You must provide a project name')
|
return False
|
available = [x.name for x in self.scaffolds]
|
diff = set(self.args.scaffold_name).difference(available)
|
if diff:
|
self.out('Unavailable scaffolds: %s' % ", ".join(sorted(diff)))
|
return False
|
|
pkg_name = self.project_vars['package']
|
|
if pkg_name == 'site' and not self.args.force_bad_name:
|
self.out(
|
'The package name "site" has a special meaning in '
|
'Python. Are you sure you want to use it as your '
|
'project\'s name?'
|
)
|
return self.confirm_bad_name(
|
'Really use "{0}"?: '.format(pkg_name)
|
)
|
|
# check if pkg_name can be imported (i.e. already exists in current
|
# $PYTHON_PATH, if so - let the user confirm
|
pkg_exists = True
|
try:
|
# use absolute imports
|
__import__(pkg_name, globals(), locals(), [], 0)
|
except ImportError as error:
|
pkg_exists = False
|
if not pkg_exists:
|
return True
|
|
if self.args.force_bad_name:
|
return True
|
self.out(
|
'A package named "{0}" already exists, are you sure you want '
|
'to use it as your project\'s name?'.format(pkg_name)
|
)
|
return self.confirm_bad_name('Really use "{0}"?: '.format(pkg_name))
|
|
def confirm_bad_name(self, prompt): # pragma: no cover
|
answer = input_('{0} [y|N]: '.format(prompt))
|
return answer.strip().lower() == 'y'
|
|
def _warn_pcreate_deprecated(self):
|
self.out(
|
'''\
|
Note: As of Pyramid 1.8, this command is deprecated. Use a specific
|
cookiecutter instead:
|
https://github.com/pylons/?query=cookiecutter
|
'''
|
)
|
|
|
if __name__ == '__main__': # pragma: no cover
|
sys.exit(main() or 0)
|
