198 lines
6.5 KiB
Python
Executable file
198 lines
6.5 KiB
Python
Executable file
#!/usr/bin/env python
|
|
# -*- coding: utf-8 -*-
|
|
|
|
"""
|
|
cookiecutter.generate
|
|
---------------------
|
|
|
|
Functions for generating a project from a project template.
|
|
"""
|
|
from __future__ import unicode_literals
|
|
from collections import OrderedDict
|
|
import io
|
|
import json
|
|
import logging
|
|
import os
|
|
import shutil
|
|
|
|
from jinja2 import FileSystemLoader, Template
|
|
from jinja2.environment import Environment
|
|
from jinja2.exceptions import TemplateSyntaxError
|
|
from binaryornot.check import is_binary
|
|
|
|
from .exceptions import NonTemplatedInputDirException
|
|
from .find import find_template
|
|
from .utils import make_sure_path_exists, work_in
|
|
from .hooks import run_hook
|
|
|
|
|
|
def generate_context(context_file='cookiecutter.json', default_context=None,
|
|
extra_context=None):
|
|
"""
|
|
Generates the context for a Cookiecutter project template.
|
|
Loads the JSON file as a Python object, with key being the JSON filename.
|
|
|
|
:param context_file: JSON file containing key/value pairs for populating
|
|
the cookiecutter's variables.
|
|
:param default_context: Dictionary containing config to take into account.
|
|
:param extra_context: Dictionary containing configuration overrides
|
|
"""
|
|
|
|
context = {}
|
|
|
|
file_handle = open(context_file)
|
|
obj = json.load(file_handle, object_pairs_hook=OrderedDict)
|
|
|
|
# Add the Python object to the context dictionary
|
|
file_name = os.path.split(context_file)[1]
|
|
file_stem = file_name.split('.')[0]
|
|
context[file_stem] = obj
|
|
|
|
# Overwrite context variable defaults with the default context from the
|
|
# user's global config, if available
|
|
if default_context:
|
|
obj.update(default_context)
|
|
if extra_context:
|
|
obj.update(extra_context)
|
|
|
|
logging.debug('Context generated is {0}'.format(context))
|
|
return context
|
|
|
|
|
|
def generate_file(project_dir, infile, context, env):
|
|
"""
|
|
1. Render the filename of infile as the name of outfile.
|
|
2. Deal with infile appropriately:
|
|
|
|
a. If infile is a binary file, copy it over without rendering.
|
|
b. If infile is a text file, render its contents and write the
|
|
rendered infile to outfile.
|
|
|
|
Precondition:
|
|
|
|
When calling `generate_file()`, the root template dir must be the
|
|
current working directory. Using `utils.work_in()` is the recommended
|
|
way to perform this directory change.
|
|
|
|
:param project_dir: Absolute path to the resulting generated project.
|
|
:param infile: Input file to generate the file from. Relative to the root
|
|
template dir.
|
|
:param context: Dict for populating the cookiecutter's variables.
|
|
:param env: Jinja2 template execution environment.
|
|
"""
|
|
|
|
logging.debug('Generating file {0}'.format(infile))
|
|
|
|
# Render the path to the output file (not including the root project dir)
|
|
outfile_tmpl = Template(infile)
|
|
outfile = os.path.join(project_dir, outfile_tmpl.render(**context))
|
|
logging.debug('outfile is {0}'.format(outfile))
|
|
|
|
# Just copy over binary files. Don't render.
|
|
logging.debug("Check {0} to see if it's a binary".format(infile))
|
|
if is_binary(infile):
|
|
logging.debug('Copying binary {0} to {1} without rendering'
|
|
.format(infile, outfile))
|
|
shutil.copyfile(infile, outfile)
|
|
else:
|
|
# Force fwd slashes on Windows for get_template
|
|
# This is a by-design Jinja issue
|
|
infile_fwd_slashes = infile.replace(os.path.sep, '/')
|
|
|
|
# Render the file
|
|
try:
|
|
tmpl = env.get_template(infile_fwd_slashes)
|
|
except TemplateSyntaxError as exception:
|
|
# Disable translated so that printed exception contains verbose
|
|
# information about syntax error location
|
|
exception.translated = False
|
|
raise
|
|
rendered_file = tmpl.render(**context)
|
|
|
|
logging.debug('Writing {0}'.format(outfile))
|
|
|
|
with io.open(outfile, 'w', encoding='utf-8') as fh:
|
|
fh.write(rendered_file)
|
|
|
|
# Apply file permissions to output file
|
|
shutil.copymode(infile, outfile)
|
|
|
|
|
|
def render_and_create_dir(dirname, context, output_dir):
|
|
"""
|
|
Renders the name of a directory, creates the directory, and
|
|
returns its path.
|
|
"""
|
|
|
|
name_tmpl = Template(dirname)
|
|
rendered_dirname = name_tmpl.render(**context)
|
|
logging.debug('Rendered dir {0} must exist in output_dir {1}'.format(
|
|
rendered_dirname,
|
|
output_dir
|
|
))
|
|
dir_to_create = os.path.normpath(
|
|
os.path.join(output_dir, rendered_dirname)
|
|
)
|
|
make_sure_path_exists(dir_to_create)
|
|
return dir_to_create
|
|
|
|
|
|
def ensure_dir_is_templated(dirname):
|
|
"""
|
|
Ensures that dirname is a templated directory name.
|
|
"""
|
|
if '{{' in dirname and '}}' in dirname:
|
|
return True
|
|
else:
|
|
raise NonTemplatedInputDirException
|
|
|
|
|
|
def generate_files(repo_dir, context=None, output_dir='.'):
|
|
"""
|
|
Renders the templates and saves them to files.
|
|
|
|
:param repo_dir: Project template input directory.
|
|
:param context: Dict for populating the template's variables.
|
|
:param output_dir: Where to output the generated project dir into.
|
|
"""
|
|
|
|
template_dir = find_template(repo_dir)
|
|
logging.debug('Generating project from {0}...'.format(template_dir))
|
|
context = context or {}
|
|
|
|
unrendered_dir = os.path.split(template_dir)[1]
|
|
ensure_dir_is_templated(unrendered_dir)
|
|
project_dir = render_and_create_dir(unrendered_dir, context, output_dir)
|
|
|
|
# We want the Jinja path and the OS paths to match. Consequently, we'll:
|
|
# + CD to the template folder
|
|
# + Set Jinja's path to '.'
|
|
#
|
|
# In order to build our files to the correct folder(s), we'll use an
|
|
# absolute path for the target folder (project_dir)
|
|
|
|
project_dir = os.path.abspath(project_dir)
|
|
logging.debug('project_dir is {0}'.format(project_dir))
|
|
|
|
# run pre-gen hook from repo_dir
|
|
with work_in(repo_dir):
|
|
run_hook('pre_gen_project', project_dir, context)
|
|
|
|
with work_in(template_dir):
|
|
env = Environment(keep_trailing_newline=True)
|
|
env.loader = FileSystemLoader('.')
|
|
|
|
for root, dirs, files in os.walk('.'):
|
|
for d in dirs:
|
|
unrendered_dir = os.path.join(project_dir,
|
|
os.path.join(root, d))
|
|
render_and_create_dir(unrendered_dir, context, output_dir)
|
|
|
|
for f in files:
|
|
infile = os.path.join(root, f)
|
|
logging.debug('f is {0}'.format(f))
|
|
generate_file(project_dir, infile, context, env)
|
|
|
|
# run post-gen hook from repo_dir
|
|
with work_in(repo_dir):
|
|
run_hook('post_gen_project', project_dir, context)
|