prompt_for_config() - Code Metrics - Inspection of "Give access to Jinja2 environment variables" - audreyr/cookiecutter - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#946)

unknown

created 2017-05-16 09:09 UTC

prompt_for_config() F

↳ Parent: Project

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	12
dl	0
loc	54
rs	3.5428
c	0
b	0
f	0

How to fix Long Method Complexity

# -*- coding: utf-8 -*-

"""
cookiecutter.prompt
---------------------

Functions for prompting the user for project info.
"""

from collections import OrderedDict
import json

import click
from past.builtins import basestring

from future.utils import iteritems

from jinja2.exceptions import UndefinedError

from .exceptions import UndefinedVariableInTemplate
from .environment import StrictEnvironment


def read_user_variable(var_name, default_value):
    """Prompt the user for the given variable and return the entered value
    or the given default.

    :param str var_name: Variable of the context to query the user
    :param default_value: Value that will be returned if no input happens
    """
    # Please see http://click.pocoo.org/4/api/#click.prompt
    return click.prompt(var_name, default=default_value)


def read_user_yes_no(question, default_value):
    """Prompt the user to reply with 'yes' or 'no' (or equivalent values).

    Note:
      Possible choices are 'true', '1', 'yes', 'y' or 'false', '0', 'no', 'n'

    :param str question: Question to the user
    :param default_value: Value that will be returned if no input happens
    """
    # Please see http://click.pocoo.org/4/api/#click.prompt
    return click.prompt(
        question,
        default=default_value,
        type=click.BOOL
    )


def read_user_choice(var_name, options):
    """Prompt the user to choose from several options for the given variable.

    The first item will be returned if no input happens.

    :param str var_name: Variable as specified in the context
    :param list options: Sequence of options that are available to select from
    :return: Exactly one item of ``options`` that has been chosen by the user
    """
    # Please see http://click.pocoo.org/4/api/#click.prompt
    if not isinstance(options, list):
        raise TypeError

    if not options:
        raise ValueError

    choice_map = OrderedDict(
        (u'{}'.format(i), value) for i, value in enumerate(options, 1)
    )
    choices = choice_map.keys()
    default = u'1'

    choice_lines = [u'{} - {}'.format(*c) for c in choice_map.items()]
    prompt = u'\n'.join((
        u'Select {}:'.format(var_name),
        u'\n'.join(choice_lines),
        u'Choose from {}'.format(u', '.join(choices))
    ))

    user_choice = click.prompt(
        prompt, type=click.Choice(choices), default=default
    )
    return choice_map[user_choice]


def process_json(user_value):
    try:
        user_dict = json.loads(
            user_value,
            object_pairs_hook=OrderedDict,
        )
    except Exception:
        # Leave it up to click to ask the user again
        raise click.UsageError('Unable to decode to JSON.')

    if not isinstance(user_dict, dict):
        # Leave it up to click to ask the user again
        raise click.UsageError('Requires JSON dict.')

    return user_dict


def read_user_dict(var_name, default_value):
    """Prompt the user to provide a dictionary of data.

    :param str var_name: Variable as specified in the context
    :param default_value: Value that will be returned if no input is provided
    :return: A Python dictionary to use in the context.
    """
    # Please see http://click.pocoo.org/4/api/#click.prompt
    if not isinstance(default_value, dict):
        raise TypeError

    default_display = 'default'

    user_value = click.prompt(
        var_name,
        default=default_display,
        type=click.STRING,
        value_proc=process_json,
    )

    if user_value == default_display:
        # Return the given default w/o any processing
        return default_value
    return user_value


def render_variable(env, raw, cookiecutter_dict):
    """Inside the prompting taken from the cookiecutter.json file, this renders
    the next variable. For example, if a project_name is "Peanut Butter
    Cookie", the repo_name could be be rendered with:

        `{{ cookiecutter.project_name.replace(" ", "_") }}`.

    This is then presented to the user as the default.

    :param Environment env: A Jinja2 Environment object.
    :param str raw: The next value to be prompted for by the user.
    :param dict cookiecutter_dict: The current context as it's gradually
        being populated with variables.
    :return: The rendered value for the default variable.
    """
    if raw is None:
        return None
    elif isinstance(raw, dict):
        return {
            render_variable(env, k, cookiecutter_dict):
                render_variable(env, v, cookiecutter_dict)
            for k, v in raw.items()
        }
    elif isinstance(raw, list):
        return [
            render_variable(env, v, cookiecutter_dict)
            for v in raw
        ]
    elif not isinstance(raw, basestring):
        raw = str(raw)

    template = env.from_string(raw)

    rendered_template = template.render(cookiecutter=cookiecutter_dict)
    return rendered_template


def prompt_choice_for_config(cookiecutter_dict, env, key, options, no_input):
    """Prompt the user which option to choose from the given. Each of the
    possible choices is rendered beforehand.
    """
    rendered_options = [
        render_variable(env, raw, cookiecutter_dict) for raw in options
    ]

    if no_input:
        return rendered_options[0]
    return read_user_choice(key, rendered_options)


def prompt_for_config(context, no_input=False):
    """
    Prompts the user to enter new config, using context as a source for the
    field names and sample values.

    :param no_input: Prompt the user at command line for manual configuration?
    """
    cookiecutter_dict = {}
    env = StrictEnvironment(context=context)

    # First pass: Handle simple and raw variables, plus choices.
    # These must be done first because the dictionaries keys and
    # values might refer to them.
    for key, raw in iteritems(context[u'cookiecutter']):
        if key.startswith(u'_'):
            cookiecutter_dict[key] = raw
            continue

        try:
            if isinstance(raw, list):
                # We are dealing with a choice variable
                val = prompt_choice_for_config(
                    cookiecutter_dict, env, key, raw, no_input
                )
                cookiecutter_dict[key] = val
            elif not isinstance(raw, dict):
                # We are dealing with a regular variable
                val = render_variable(env, raw, cookiecutter_dict)

                if not no_input:
                    val = read_user_variable(key, val)

                cookiecutter_dict[key] = val
        except UndefinedError as err:
            msg = "Unable to render variable '{}'".format(key)
            raise UndefinedVariableInTemplate(msg, err, context)

    # Second pass; handle the dictionaries.
    for key, raw in iteritems(context[u'cookiecutter']):

        try:
            if isinstance(raw, dict) and not key.startswith(u'_'):
                # We are dealing with a dict variable
                val = render_variable(env, raw, cookiecutter_dict)

                if not no_input:
                    val = read_user_dict(key, val)

                cookiecutter_dict[key] = val
        except UndefinedError as err:
            msg = "Unable to render variable '{}'".format(key)
            raise UndefinedVariableInTemplate(msg, err, context)

    return cookiecutter_dict


1			# -- coding: utf-8 --
2
3			"""
4			cookiecutter.prompt
5			---------------------
6
7			Functions for prompting the user for project info.
8			"""
9
10			from collections import OrderedDict
11			import json
12
13			import click
14			from past.builtins import basestring
15
16			from future.utils import iteritems
17
18			from jinja2.exceptions import UndefinedError
19
20			from .exceptions import UndefinedVariableInTemplate
21			from .environment import StrictEnvironment
22
23
24			def read_user_variable(var_name, default_value):
25			"""Prompt the user for the given variable and return the entered value
26			or the given default.
27
28			:param str var_name: Variable of the context to query the user
29			:param default_value: Value that will be returned if no input happens
30			"""
31			# Please see http://click.pocoo.org/4/api/#click.prompt
32			return click.prompt(var_name, default=default_value)
33
34
35			def read_user_yes_no(question, default_value):
36			"""Prompt the user to reply with 'yes' or 'no' (or equivalent values).
37
38			Note:
39			Possible choices are 'true', '1', 'yes', 'y' or 'false', '0', 'no', 'n'
40
41			:param str question: Question to the user
42			:param default_value: Value that will be returned if no input happens
43			"""
44			# Please see http://click.pocoo.org/4/api/#click.prompt
45			return click.prompt(
46			question,
47			default=default_value,
48			type=click.BOOL
49			)
50
51
52			def read_user_choice(var_name, options):
53			"""Prompt the user to choose from several options for the given variable.
54
55			The first item will be returned if no input happens.
56
57			:param str var_name: Variable as specified in the context
58			:param list options: Sequence of options that are available to select from
59			:return: Exactly one item of ``options`` that has been chosen by the user
60			"""
61			# Please see http://click.pocoo.org/4/api/#click.prompt
62			if not isinstance(options, list):
63			raise TypeError
64
65			if not options:
66			raise ValueError
67
68			choice_map = OrderedDict(
69			(u'{}'.format(i), value) for i, value in enumerate(options, 1)
70			)
71			choices = choice_map.keys()
72			default = u'1'
73
74			choice_lines = [u'{} - {}'.format(*c) for c in choice_map.items()]
75			prompt = u'\n'.join((
76			u'Select {}:'.format(var_name),
77			u'\n'.join(choice_lines),
78			u'Choose from {}'.format(u', '.join(choices))
79			))
80
81			user_choice = click.prompt(
82			prompt, type=click.Choice(choices), default=default
83			)
84			return choice_map[user_choice]
85
86
87			def process_json(user_value):
88			try:
89			user_dict = json.loads(
90			user_value,
91			object_pairs_hook=OrderedDict,
92			)
93			except Exception:
94			# Leave it up to click to ask the user again
95			raise click.UsageError('Unable to decode to JSON.')
96
97			if not isinstance(user_dict, dict):
98			# Leave it up to click to ask the user again
99			raise click.UsageError('Requires JSON dict.')
100
101			return user_dict
102
103
104			def read_user_dict(var_name, default_value):
105			"""Prompt the user to provide a dictionary of data.
106
107			:param str var_name: Variable as specified in the context
108			:param default_value: Value that will be returned if no input is provided
109			:return: A Python dictionary to use in the context.
110			"""
111			# Please see http://click.pocoo.org/4/api/#click.prompt
112			if not isinstance(default_value, dict):
113			raise TypeError
114
115			default_display = 'default'
116
117			user_value = click.prompt(
118			var_name,
119			default=default_display,
120			type=click.STRING,
121			value_proc=process_json,
122			)
123
124			if user_value == default_display:
125			# Return the given default w/o any processing
126			return default_value
127			return user_value
128
129
130			def render_variable(env, raw, cookiecutter_dict):
131			"""Inside the prompting taken from the cookiecutter.json file, this renders
132			the next variable. For example, if a project_name is "Peanut Butter
133			Cookie", the repo_name could be be rendered with:
134
135			`{{ cookiecutter.project_name.replace(" ", "_") }}`.
136
137			This is then presented to the user as the default.
138
139			:param Environment env: A Jinja2 Environment object.
140			:param str raw: The next value to be prompted for by the user.
141			:param dict cookiecutter_dict: The current context as it's gradually
142			being populated with variables.
143			:return: The rendered value for the default variable.
144			"""
145			if raw is None:
146			return None
147			elif isinstance(raw, dict):
148			return {
149			render_variable(env, k, cookiecutter_dict):
150			render_variable(env, v, cookiecutter_dict)
151			for k, v in raw.items()
152			}
153			elif isinstance(raw, list):
154			return [
155			render_variable(env, v, cookiecutter_dict)
156			for v in raw
157			]
158			elif not isinstance(raw, basestring):
159			raw = str(raw)
160
161			template = env.from_string(raw)
162
163			rendered_template = template.render(cookiecutter=cookiecutter_dict)
164			return rendered_template
165
166
167			def prompt_choice_for_config(cookiecutter_dict, env, key, options, no_input):
168			"""Prompt the user which option to choose from the given. Each of the
169			possible choices is rendered beforehand.
170			"""
171			rendered_options = [
172			render_variable(env, raw, cookiecutter_dict) for raw in options
173			]
174
175			if no_input:
176			return rendered_options[0]
177			return read_user_choice(key, rendered_options)
178
179
180			def prompt_for_config(context, no_input=False):
181			"""
182			Prompts the user to enter new config, using context as a source for the
183			field names and sample values.
184
185			:param no_input: Prompt the user at command line for manual configuration?
186			"""
187			cookiecutter_dict = {}
188			env = StrictEnvironment(context=context)
189
190			# First pass: Handle simple and raw variables, plus choices.
191			# These must be done first because the dictionaries keys and
192			# values might refer to them.
193			for key, raw in iteritems(context[u'cookiecutter']):
194			if key.startswith(u'_'):
195			cookiecutter_dict[key] = raw
196			continue
197
198			try:
199			if isinstance(raw, list):
200			# We are dealing with a choice variable
201			val = prompt_choice_for_config(
202			cookiecutter_dict, env, key, raw, no_input
203			)
204			cookiecutter_dict[key] = val
205			elif not isinstance(raw, dict):
206			# We are dealing with a regular variable
207			val = render_variable(env, raw, cookiecutter_dict)
208
209			if not no_input:
210			val = read_user_variable(key, val)
211
212			cookiecutter_dict[key] = val
213			except UndefinedError as err:
214			msg = "Unable to render variable '{}'".format(key)
215			raise UndefinedVariableInTemplate(msg, err, context)
216
217			# Second pass; handle the dictionaries.
218			for key, raw in iteritems(context[u'cookiecutter']):
219
220			try:
221			if isinstance(raw, dict) and not key.startswith(u'_'):
222			# We are dealing with a dict variable
223			val = render_variable(env, raw, cookiecutter_dict)
224
225			if not no_input:
226			val = read_user_dict(key, val)
227
228			cookiecutter_dict[key] = val
229			except UndefinedError as err:
230			msg = "Unable to render variable '{}'".format(key)
231			raise UndefinedVariableInTemplate(msg, err, context)
232
233			return cookiecutter_dict
234

audreyr / cookiecutter

Pull Request — master (#946)

prompt_for_config() F

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Complexity

Duplication Side-by-Side

Filter issues like