cookiecutter.generate.generate_files()   F
last analyzed

Complexity

Conditions 14

Size

Total Lines 133
Code Lines 88

Duplication

Lines 0
Ratio 0 %

Importance

Changes 0
Metric Value
eloc 88
dl 0
loc 133
rs 2.9127
c 0
b 0
f 0
cc 14
nop 4

How to fix   Long Method    Complexity   

Long Method

Small methods make your code easier to understand, in particular if combined with a good name. Besides, if your method is small, finding a good name is usually much easier.

For example, if you find yourself adding comments to a method's body, this is usually a good sign to extract the commented part to a new method, and use the comment as a starting point when coming up with a good name for this new method.

Commonly applied refactorings include:

Complexity

Complex classes like cookiecutter.generate.generate_files() often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

1
# -*- coding: utf-8 -*-
2
3
"""Functions for generating a project from a project template."""
4
from __future__ import unicode_literals
5
6
import fnmatch
7
import io
8
import json
9
import logging
10
import os
11
import shutil
12
from collections import OrderedDict
13
14
from binaryornot.check import is_binary
15
from jinja2 import FileSystemLoader
16
from jinja2.exceptions import TemplateSyntaxError, UndefinedError
17
18
from cookiecutter.environment import StrictEnvironment
19
from cookiecutter.exceptions import (
20
    NonTemplatedInputDirException,
21
    ContextDecodingException,
22
    FailedHookException,
23
    OutputDirExistsException,
24
    UndefinedVariableInTemplate
25
)
26
from cookiecutter.find import find_template
27
from cookiecutter.hooks import run_hook
28
from cookiecutter.utils import make_sure_path_exists, work_in, rmtree
29
30
logger = logging.getLogger(__name__)
31
32
33
def is_copy_only_path(path, context):
34
    """Check whether the given `path` should only be copied and not rendered.
35
36
    Returns True if `path` matches a pattern in the given `context` dict,
37
    otherwise False.
38
39
    :param path: A file-system path referring to a file or dir that
40
        should be rendered or just copied.
41
    :param context: cookiecutter context.
42
    """
43
    try:
44
        for dont_render in context['cookiecutter']['_copy_without_render']:
45
            if fnmatch.fnmatch(path, dont_render):
46
                return True
47
    except KeyError:
48
        return False
49
50
    return False
51
52
53
def apply_overwrites_to_context(context, overwrite_context):
54
    """Modify the given context in place based on the overwrite_context."""
55
    for variable, overwrite in overwrite_context.items():
56
        if variable not in context:
57
            # Do not include variables which are not used in the template
58
            continue
59
60
        context_value = context[variable]
61
62
        if isinstance(context_value, list):
63
            # We are dealing with a choice variable
64
            if overwrite in context_value:
65
                # This overwrite is actually valid for the given context
66
                # Let's set it as default (by definition first item in list)
67
                # see ``cookiecutter.prompt.prompt_choice_for_config``
68
                context_value.remove(overwrite)
69
                context_value.insert(0, overwrite)
70
        else:
71
            # Simply overwrite the value for this variable
72
            context[variable] = overwrite
73
74
75
def generate_context(context_file='cookiecutter.json', default_context=None,
76
                     extra_context=None):
77
    """Generate the context for a Cookiecutter project template.
78
79
    Loads the JSON file as a Python object, with key being the JSON filename.
80
81
    :param context_file: JSON file containing key/value pairs for populating
82
        the cookiecutter's variables.
83
    :param default_context: Dictionary containing config to take into account.
84
    :param extra_context: Dictionary containing configuration overrides
85
    """
86
    context = OrderedDict([])
87
88
    try:
89
        with open(context_file) as file_handle:
90
            obj = json.load(file_handle, object_pairs_hook=OrderedDict)
91
    except ValueError as e:
92
        # JSON decoding error.  Let's throw a new exception that is more
93
        # friendly for the developer or user.
94
        full_fpath = os.path.abspath(context_file)
95
        json_exc_message = str(e)
96
        our_exc_message = (
97
            'JSON decoding error while loading "{0}".  Decoding'
98
            ' error details: "{1}"'.format(full_fpath, json_exc_message))
99
        raise ContextDecodingException(our_exc_message)
100
101
    # Add the Python object to the context dictionary
102
    file_name = os.path.split(context_file)[1]
103
    file_stem = file_name.split('.')[0]
104
    context[file_stem] = obj
105
106
    # Overwrite context variable defaults with the default context from the
107
    # user's global config, if available
108
    if default_context:
109
        apply_overwrites_to_context(obj, default_context)
110
    if extra_context:
111
        apply_overwrites_to_context(obj, extra_context)
112
113
    logger.debug('Context generated is {}'.format(context))
114
    return context
115
116
117
def generate_file(project_dir, infile, context, env):
118
    """Render filename of infile as name of outfile, handle infile correctly.
119
120
    Dealing with infile appropriately:
121
122
        a. If infile is a binary file, copy it over without rendering.
123
        b. If infile is a text file, render its contents and write the
124
           rendered infile to outfile.
125
126
    Precondition:
127
128
        When calling `generate_file()`, the root template dir must be the
129
        current working directory. Using `utils.work_in()` is the recommended
130
        way to perform this directory change.
131
132
    :param project_dir: Absolute path to the resulting generated project.
133
    :param infile: Input file to generate the file from. Relative to the root
134
        template dir.
135
    :param context: Dict for populating the cookiecutter's variables.
136
    :param env: Jinja2 template execution environment.
137
    """
138
    logger.debug('Processing file {}'.format(infile))
139
140
    # Render the path to the output file (not including the root project dir)
141
    outfile_tmpl = env.from_string(infile)
142
143
    outfile = os.path.join(project_dir, outfile_tmpl.render(**context))
144
    file_name_is_empty = os.path.isdir(outfile)
145
    if file_name_is_empty:
146
        logger.debug('The resulting file name is empty: {0}'.format(outfile))
147
        return
148
149
    logger.debug('Created file at {0}'.format(outfile))
150
151
    # Just copy over binary files. Don't render.
152
    logger.debug("Check {} to see if it's a binary".format(infile))
153
    if is_binary(infile):
154
        logger.debug(
155
            'Copying binary {} to {} without rendering'
156
            ''.format(infile, outfile)
157
        )
158
        shutil.copyfile(infile, outfile)
159
    else:
160
        # Force fwd slashes on Windows for get_template
161
        # This is a by-design Jinja issue
162
        infile_fwd_slashes = infile.replace(os.path.sep, '/')
163
164
        # Render the file
165
        try:
166
            tmpl = env.get_template(infile_fwd_slashes)
167
        except TemplateSyntaxError as exception:
168
            # Disable translated so that printed exception contains verbose
169
            # information about syntax error location
170
            exception.translated = False
171
            raise
172
        rendered_file = tmpl.render(**context)
173
174
        logger.debug('Writing contents to file {}'.format(outfile))
175
176
        with io.open(outfile, 'w', encoding='utf-8') as fh:
177
            fh.write(rendered_file)
178
179
    # Apply file permissions to output file
180
    shutil.copymode(infile, outfile)
181
182
183
def render_and_create_dir(dirname, context, output_dir, environment,
184
                          overwrite_if_exists=False):
185
    """Render name of a directory, create the directory, return its path."""
186
    name_tmpl = environment.from_string(dirname)
187
    rendered_dirname = name_tmpl.render(**context)
188
189
    dir_to_create = os.path.normpath(
190
        os.path.join(output_dir, rendered_dirname)
191
    )
192
193
    logger.debug('Rendered dir {} must exist in output_dir {}'.format(
194
        dir_to_create,
195
        output_dir
196
    ))
197
198
    output_dir_exists = os.path.exists(dir_to_create)
199
200
    if output_dir_exists:
201
        if overwrite_if_exists:
202
            logger.debug(
203
                'Output directory {} already exists,'
204
                'overwriting it'.format(dir_to_create)
205
            )
206
        else:
207
            msg = 'Error: "{}" directory already exists'.format(dir_to_create)
208
            raise OutputDirExistsException(msg)
209
    else:
210
        make_sure_path_exists(dir_to_create)
211
212
    return dir_to_create, not output_dir_exists
213
214
215
def ensure_dir_is_templated(dirname):
216
    """Ensure that dirname is a templated directory name."""
217
    if '{{' in dirname and '}}' in dirname:
218
        return True
219
    else:
220
        raise NonTemplatedInputDirException
221
222
223
def _run_hook_from_repo_dir(repo_dir, hook_name, project_dir, context,
224
                            delete_project_on_failure):
225
    """Run hook from repo directory, clean project directory if hook fails.
226
227
    :param repo_dir: Project template input directory.
228
    :param hook_name: The hook to execute.
229
    :param project_dir: The directory to execute the script from.
230
    :param context: Cookiecutter project context.
231
    :param delete_project_on_failure: Delete the project directory on hook
232
        failure?
233
    """
234
    with work_in(repo_dir):
235
        try:
236
            run_hook(hook_name, project_dir, context)
237
        except FailedHookException:
238
            if delete_project_on_failure:
239
                rmtree(project_dir)
240
            logger.error(
241
                "Stopping generation because {} hook "
242
                "script didn't exit successfully".format(hook_name)
243
            )
244
            raise
245
246
247
def generate_files(repo_dir, context=None, output_dir='.',
248
                   overwrite_if_exists=False):
249
    """Render the templates and saves them to files.
250
251
    :param repo_dir: Project template input directory.
252
    :param context: Dict for populating the template's variables.
253
    :param output_dir: Where to output the generated project dir into.
254
    :param overwrite_if_exists: Overwrite the contents of the output directory
255
        if it exists.
256
    """
257
    template_dir = find_template(repo_dir)
258
    logger.debug('Generating project from {}...'.format(template_dir))
259
    context = context or OrderedDict([])
260
261
    unrendered_dir = os.path.split(template_dir)[1]
262
    ensure_dir_is_templated(unrendered_dir)
263
    env = StrictEnvironment(
264
        context=context,
265
        keep_trailing_newline=True,
266
    )
267
    try:
268
        project_dir, output_directory_created = render_and_create_dir(
269
            unrendered_dir,
270
            context,
271
            output_dir,
272
            env,
273
            overwrite_if_exists
274
        )
275
    except UndefinedError as err:
276
        msg = "Unable to create project directory '{}'".format(unrendered_dir)
277
        raise UndefinedVariableInTemplate(msg, err, context)
278
279
    # We want the Jinja path and the OS paths to match. Consequently, we'll:
280
    #   + CD to the template folder
281
    #   + Set Jinja's path to '.'
282
    #
283
    #  In order to build our files to the correct folder(s), we'll use an
284
    # absolute path for the target folder (project_dir)
285
286
    project_dir = os.path.abspath(project_dir)
287
    logger.debug('Project directory is {}'.format(project_dir))
288
289
    # if we created the output directory, then it's ok to remove it
290
    # if rendering fails
291
    delete_project_on_failure = output_directory_created
292
293
    _run_hook_from_repo_dir(
294
        repo_dir,
295
        'pre_gen_project',
296
        project_dir,
297
        context,
298
        delete_project_on_failure
299
    )
300
301
    with work_in(template_dir):
302
        env.loader = FileSystemLoader('.')
303
304
        for root, dirs, files in os.walk('.'):
305
            # We must separate the two types of dirs into different lists.
306
            # The reason is that we don't want ``os.walk`` to go through the
307
            # unrendered directories, since they will just be copied.
308
            copy_dirs = []
309
            render_dirs = []
310
311
            for d in dirs:
312
                d_ = os.path.normpath(os.path.join(root, d))
313
                # We check the full path, because that's how it can be
314
                # specified in the ``_copy_without_render`` setting, but
315
                # we store just the dir name
316
                if is_copy_only_path(d_, context):
317
                    copy_dirs.append(d)
318
                else:
319
                    render_dirs.append(d)
320
321
            for copy_dir in copy_dirs:
322
                indir = os.path.normpath(os.path.join(root, copy_dir))
323
                outdir = os.path.normpath(os.path.join(project_dir, indir))
324
                logger.debug(
325
                    'Copying dir {} to {} without rendering'
326
                    ''.format(indir, outdir)
327
                )
328
                shutil.copytree(indir, outdir)
329
330
            # We mutate ``dirs``, because we only want to go through these dirs
331
            # recursively
332
            dirs[:] = render_dirs
333
            for d in dirs:
334
                unrendered_dir = os.path.join(project_dir, root, d)
335
                try:
336
                    render_and_create_dir(
337
                        unrendered_dir,
338
                        context,
339
                        output_dir,
340
                        env,
341
                        overwrite_if_exists
342
                    )
343
                except UndefinedError as err:
344
                    if delete_project_on_failure:
345
                        rmtree(project_dir)
346
                    _dir = os.path.relpath(unrendered_dir, output_dir)
347
                    msg = "Unable to create directory '{}'".format(_dir)
348
                    raise UndefinedVariableInTemplate(msg, err, context)
349
350
            for f in files:
351
                infile = os.path.normpath(os.path.join(root, f))
352
                if is_copy_only_path(infile, context):
353
                    outfile_tmpl = env.from_string(infile)
354
                    outfile_rendered = outfile_tmpl.render(**context)
355
                    outfile = os.path.join(project_dir, outfile_rendered)
356
                    logger.debug(
357
                        'Copying file {} to {} without rendering'
358
                        ''.format(infile, outfile)
359
                    )
360
                    shutil.copyfile(infile, outfile)
361
                    shutil.copymode(infile, outfile)
362
                    continue
363
                try:
364
                    generate_file(project_dir, infile, context, env)
365
                except UndefinedError as err:
366
                    if delete_project_on_failure:
367
                        rmtree(project_dir)
368
                    msg = "Unable to create file '{}'".format(infile)
369
                    raise UndefinedVariableInTemplate(msg, err, context)
370
371
    _run_hook_from_repo_dir(
372
        repo_dir,
373
        'post_gen_project',
374
        project_dir,
375
        context,
376
        delete_project_on_failure
377
    )
378
379
    return project_dir
380