Fixed #17042 -- Extended startproject and startapp management commands to better…

Fixed #17042 -- Extended startproject and startapp management commands to better handle custom app and project templates. Many thanks to Preston Holmes for his initial patch and Alex Gaynor, Carl Meyer, Donald Stufft, Jacob Kaplan-Moss and Julien Phalip for code reviewing.

* Added ability to pass the project or app directory path as the second argument
* Added ``--template`` option for specifying custom project and app templates
* Cleaned up admin_scripts tests a little while I was there

git-svn-id: http://code.djangoproject.com/svn/django/trunk@17246 bcc190cf-cafb-0310-a4f2-bffc1f526a37

django/conf/project_template/project_name/settings.py

@@ -81,7 +81,7 @@ STATICFILES_FINDERS = (
 )
 
 # Make this unique, and don't share it with anybody.
-SECRET_KEY = ''
+SECRET_KEY = '{{ secret_key }}'
 
 # List of callables that know how to import templates from various sources.
 TEMPLATE_LOADERS = (

django/core/management/__init__.py

@@ -77,9 +77,7 @@ def get_commands():
     in that package are registered.
 
     Core commands are always included. If a settings module has been
-    specified, user-defined commands will also be included, the
-    startproject command will be disabled, and the startapp command
-    will be modified to use the directory in which the settings module appears.
+    specified, user-defined commands will also be included.
 
     The dictionary is in the format {command_name: app_name}. Key-value
     pairs from this dictionary can then be used in calls to

django/core/management/base.py

@@ -3,9 +3,10 @@ Base classes for writing management commands (named commands which can
 be executed through ``django-admin.py`` or ``manage.py``).
 
 """
-
+from __future__ import with_statement
 import os
 import sys
+
 from optparse import make_option, OptionParser
 import traceback
 
@@ -14,6 +15,7 @@ from django.core.exceptions import ImproperlyConfigured
 from django.core.management.color import color_style
 from django.utils.encoding import smart_str
 
+
 class CommandError(Exception):
     """
     Exception class indicating a problem while executing a management
@@ -29,6 +31,7 @@ class CommandError(Exception):
     """
     pass
 
+
 def handle_default_options(options):
     """
     Include any default options that all commands should accept here
@@ -41,6 +44,7 @@ def handle_default_options(options):
     if options.pythonpath:
         sys.path.insert(0, options.pythonpath)
 
+
 class BaseCommand(object):
     """
     The base class from which all management commands ultimately
@@ -134,7 +138,7 @@ class BaseCommand(object):
     # Configuration shortcuts that alter various logic.
     can_import_settings = True
     requires_model_validation = True
-    output_transaction = False # Whether to wrap the output in a "BEGIN; COMMIT;"
+    output_transaction = False  # Whether to wrap the output in a "BEGIN; COMMIT;"
 
     def __init__(self):
         self.style = color_style()
@@ -275,6 +279,7 @@ class BaseCommand(object):
         """
         raise NotImplementedError()
 
+
 class AppCommand(BaseCommand):
     """
     A management command which takes one or more installed application
@@ -310,6 +315,7 @@ class AppCommand(BaseCommand):
         """
         raise NotImplementedError()
 
+
 class LabelCommand(BaseCommand):
     """
     A management command which takes one or more arbitrary arguments
@@ -345,6 +351,7 @@ class LabelCommand(BaseCommand):
         """
         raise NotImplementedError()
 
+
 class NoArgsCommand(BaseCommand):
     """
     A command which takes no arguments on the command line.
@@ -369,74 +376,3 @@ class NoArgsCommand(BaseCommand):
 
         """
         raise NotImplementedError()
-
-def copy_helper(style, app_or_project, name, directory):
-    """
-    Copies either a Django application layout template or a Django project
-    layout template into the specified directory.
-
-    """
-    # style -- A color style object (see django.core.management.color).
-    # app_or_project -- The string 'app' or 'project'.
-    # name -- The name of the application or project.
-    # directory -- The directory to which the layout template should be copied.
-    import re
-    import shutil
-
-    if not re.search(r'^[_a-zA-Z]\w*$', name): # If it's not a valid directory name.
-        # Provide a smart error message, depending on the error.
-        if not re.search(r'^[_a-zA-Z]', name):
-            message = 'make sure the name begins with a letter or underscore'
-        else:
-            message = 'use only numbers, letters and underscores'
-        raise CommandError("%r is not a valid %s name. Please %s." % (name, app_or_project, message))
-    top_dir = os.path.join(directory, name)
-    try:
-        os.mkdir(top_dir)
-    except OSError, e:
-        raise CommandError(e)
-
-    # Determine where the app or project templates are. Use
-    # django.__path__[0] because we don't know into which directory
-    # django has been installed.
-    template_dir = os.path.join(django.__path__[0], 'conf', '%s_template' % app_or_project)
-
-    for d, subdirs, files in os.walk(template_dir):
-        relative_dir = d[len(template_dir)+1:].replace('%s_name' % app_or_project, name)
-        if relative_dir:
-            os.mkdir(os.path.join(top_dir, relative_dir))
-        for subdir in subdirs[:]:
-            if subdir.startswith('.'):
-                subdirs.remove(subdir)
-        for f in files:
-            if not f.endswith('.py'):
-                # Ignore .pyc, .pyo, .py.class etc, as they cause various
-                # breakages.
-                continue
-            path_old = os.path.join(d, f)
-            path_new = os.path.join(top_dir, relative_dir, f.replace('%s_name' % app_or_project, name))
-            fp_old = open(path_old, 'r')
-            fp_new = open(path_new, 'w')
-            fp_new.write(fp_old.read().replace('{{ %s_name }}' % app_or_project, name))
-            fp_old.close()
-            fp_new.close()
-            try:
-                shutil.copymode(path_old, path_new)
-                _make_writeable(path_new)
-            except OSError:
-                sys.stderr.write(style.NOTICE("Notice: Couldn't set permission bits on %s. You're probably using an uncommon filesystem setup. No problem.\n" % path_new))
-
-def _make_writeable(filename):
-    """
-    Make sure that the file is writeable. Useful if our source is
-    read-only.
-
-    """
-    import stat
-    if sys.platform.startswith('java'):
-        # On Jython there is no os.access()
-        return
-    if not os.access(filename, os.W_OK):
-        st = os.stat(filename)
-        new_permissions = stat.S_IMODE(st.st_mode) | stat.S_IWUSR
-        os.chmod(filename, new_permissions)

django/core/management/commands/makemessages.py

@@ -13,7 +13,7 @@ from django.utils.jslex import prepare_js_for_gettext
 
 plural_forms_re = re.compile(r'^(?P<value>"Plural-Forms.+?\\n")\s*$', re.MULTILINE | re.DOTALL)
 
-def handle_extensions(extensions=('html',)):
+def handle_extensions(extensions=('html',), ignored=('py',)):
     """
     Organizes multiple extensions that are separated with commas or passed by
     using --extension/-e multiple times. Note that the .py extension is ignored
@@ -31,11 +31,11 @@ def handle_extensions(extensions=('html',)):
     """
     ext_list = []
     for ext in extensions:
-        ext_list.extend(ext.replace(' ','').split(','))
+        ext_list.extend(ext.replace(' ', '').split(','))
     for i, ext in enumerate(ext_list):
         if not ext.startswith('.'):
             ext_list[i] = '.%s' % ext_list[i]
-    return set([x for x in ext_list if x != '.py'])
+    return set([x for x in ext_list if x.strip('.') not in ignored])
 
 def _popen(cmd):
     """

django/core/management/commands/startapp.py

-import os
-
-from django.core.management.base import copy_helper, CommandError, LabelCommand
+from django.core.management.base import CommandError
+from django.core.management.templates import TemplateCommand
 from django.utils.importlib import import_module
 
-class Command(LabelCommand):
-    help = "Creates a Django app directory structure for the given app name in the current directory."
-    args = "[appname]"
-    label = 'application name'
 
-    requires_model_validation = False
-    # Can't import settings during this command, because they haven't
-    # necessarily been created.
-    can_import_settings = False
+class Command(TemplateCommand):
+    help = ("Creates a Django app directory structure for the given app "
+            "name in the current directory or optionally in the given "
+            "directory.")
 
-    def handle_label(self, app_name, directory=None, **options):
-        if directory is None:
-            directory = os.getcwd()
+    def handle(self, app_name=None, target=None, **options):
+        if app_name is None:
+            raise CommandError("you must provide an app name")
 
         # Check that the app_name cannot be imported.
         try:
@@ -23,6 +18,8 @@ class Command(LabelCommand):
         except ImportError:
             pass
         else:
-            raise CommandError("%r conflicts with the name of an existing Python module and cannot be used as an app name. Please try another name." % app_name)
+            raise CommandError("%r conflicts with the name of an existing "
+                               "Python module and cannot be used as an app "
+                               "name. Please try another name." % app_name)
 
-        copy_helper(self.style, 'app', app_name, directory)
+        super(Command, self).handle('app', app_name, target, **options)

django/core/management/commands/startproject.py

-from django.core.management.base import copy_helper, CommandError, LabelCommand
-from django.utils.importlib import import_module
-import os
-import re
 from random import choice
 
-class Command(LabelCommand):
-    help = "Creates a Django project directory structure for the given project name in the current directory."
-    args = "[projectname]"
-    label = 'project name'
+from django.core.management.base import CommandError
+from django.core.management.templates import TemplateCommand
+from django.utils.importlib import import_module
+
 
-    requires_model_validation = False
-    # Can't import settings during this command, because they haven't
-    # necessarily been created.
-    can_import_settings = False
+class Command(TemplateCommand):
+    help = ("Creates a Django project directory structure for the given "
+            "project name in the current directory or optionally in the "
+            "given directory.")
 
-    def handle_label(self, project_name, **options):
-        directory = os.getcwd()
+    def handle(self, project_name=None, target=None, *args, **options):
+        if project_name is None:
+            raise CommandError("you must provide a project name")
 
         # Check that the project_name cannot be imported.
         try:
@@ -23,15 +20,13 @@ class Command(LabelCommand):
         except ImportError:
             pass
         else:
-            raise CommandError("%r conflicts with the name of an existing Python module and cannot be used as a project name. Please try another name." % project_name)
+            raise CommandError("%r conflicts with the name of an existing "
+                               "Python module and cannot be used as a "
+                               "project name. Please try another name." %
+                               project_name)
 
-        copy_helper(self.style, 'project', project_name, directory)
+        # Create a random SECRET_KEY hash to put it in the main settings.
+        chars = 'abcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*(-_=+)'
+        options['secret_key'] = ''.join([choice(chars) for i in range(50)])
 
-        # Create a random SECRET_KEY hash, and put it in the main settings.
-        main_settings_file = os.path.join(directory, project_name, project_name, 'settings.py')
-        settings_contents = open(main_settings_file, 'r').read()
-        fp = open(main_settings_file, 'w')
-        secret_key = ''.join([choice('abcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*(-_=+)') for i in range(50)])
-        settings_contents = re.sub(r"(?<=SECRET_KEY = ')'", secret_key + "'", settings_contents)
-        fp.write(settings_contents)
-        fp.close()
+        super(Command, self).handle('project', project_name, target, **options)

django/utils/archive.py

+"""
+Based on "python-archive" -- http://pypi.python.org/pypi/python-archive/
+
+Copyright (c) 2010 Gary Wilson Jr. <gary.wilson@gmail.com> and contributers.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+"""
+import os
+import shutil
+import sys
+import tarfile
+import zipfile
+
+
+class ArchiveException(Exception):
+    """
+    Base exception class for all archive errors.
+    """
+
+
+class UnrecognizedArchiveFormat(ArchiveException):
+    """
+    Error raised when passed file is not a recognized archive format.
+    """
+
+
+def extract(path, to_path=''):
+    """
+    Unpack the tar or zip file at the specified path to the directory
+    specified by to_path.
+    """
+    Archive(path).extract(to_path)
+
+
+class Archive(object):
+    """
+    The external API class that encapsulates an archive implementation.
+    """
+    def __init__(self, file):
+        self._archive = self._archive_cls(file)(file)
+
+    @staticmethod
+    def _archive_cls(file):
+        cls = None
+        if isinstance(file, basestring):
+            filename = file
+        else:
+            try:
+                filename = file.name
+            except AttributeError:
+                raise UnrecognizedArchiveFormat(
+                    "File object not a recognized archive format.")
+        base, tail_ext = os.path.splitext(filename.lower())
+        cls = extension_map.get(tail_ext)
+        if not cls:
+            base, ext = os.path.splitext(base)
+            cls = extension_map.get(ext)
+        if not cls:
+            raise UnrecognizedArchiveFormat(
+                "Path not a recognized archive format: %s" % filename)
+        return cls
+
+    def extract(self, to_path=''):
+        self._archive.extract(to_path)
+
+    def list(self):
+        self._archive.list()
+
+
+class BaseArchive(object):
+    """
+    Base Archive class.  Implementations should inherit this class.
+    """
+    def split_leading_dir(self, path):
+        path = str(path)
+        path = path.lstrip('/').lstrip('\\')
+        if '/' in path and (('\\' in path and path.find('/') < path.find('\\'))
+                            or '\\' not in path):
+            return path.split('/', 1)
+        elif '\\' in path:
+            return path.split('\\', 1)
+        else:
+            return path, ''
+
+    def has_leading_dir(self, paths):
+        """
+        Returns true if all the paths have the same leading path name
+        (i.e., everything is in one subdirectory in an archive)
+        """
+        common_prefix = None
+        for path in paths:
+            prefix, rest = self.split_leading_dir(path)
+            if not prefix:
+                return False
+            elif common_prefix is None:
+                common_prefix = prefix
+            elif prefix != common_prefix:
+                return False
+        return True
+
+    def extract(self):
+        raise NotImplementedError
+
+    def list(self):
+        raise NotImplementedError
+
+
+class TarArchive(BaseArchive):
+
+    def __init__(self, file):
+        self._archive = tarfile.open(file)
+
+    def list(self, *args, **kwargs):
+        self._archive.list(*args, **kwargs)
+
+    def extract(self, to_path):
+        # note: python<=2.5 doesnt seem to know about pax headers, filter them
+        members = [member for member in self._archive.getmembers()
+                   if member.name != 'pax_global_header']
+        leading = self.has_leading_dir(members)
+        for member in members:
+            name = member.name
+            if leading:
+                name = self.split_leading_dir(name)[1]
+            filename = os.path.join(to_path, name)
+            if member.isdir():
+                if not os.path.exists(filename):
+                    os.makedirs(filename)
+            else:
+                try:
+                    extracted = self._archive.extractfile(member)
+                except (KeyError, AttributeError):
+                    # Some corrupt tar files seem to produce this
+                    # (specifically bad symlinks)
+                    print ("In the tar file %s the member %s is invalid: %s" %
+                           (name, member.name, sys.exc_info()[1]))
+                else:
+                    dirname = os.path.dirname(filename)
+                    if not os.path.exists(dirname):
+                        os.makedirs(dirname)
+                    with open(filename, 'wb') as outfile:
+                        shutil.copyfileobj(extracted, outfile)
+                finally:
+                    if extracted:
+                        extracted.close()
+
+
+class ZipArchive(BaseArchive):
+
+    def __init__(self, file):
+        self._archive = zipfile.ZipFile(file)
+
+    def list(self, *args, **kwargs):
+        self._archive.printdir(*args, **kwargs)
+
+    def extract(self, to_path):
+        namelist = self._archive.namelist()
+        leading = self.has_leading_dir(namelist)
+        for name in namelist:
+            data = self._archive.read(name)
+            if leading:
+                name = self.split_leading_dir(name)[1]
+            filename = os.path.join(to_path, name)
+            dirname = os.path.dirname(filename)
+            if dirname and not os.path.exists(dirname):
+                os.makedirs(dirname)
+            if filename.endswith(('/', '\\')):
+                # A directory
+                if not os.path.exists(filename):
+                    os.makedirs(filename)
+            else:
+                with open(filename, 'wb') as outfile:
+                    outfile.write(data)
+
+extension_map = {
+    '.tar': TarArchive,
+    '.tar.bz2': TarArchive,
+    '.tar.gz': TarArchive,
+    '.tgz': TarArchive,
+    '.tz2': TarArchive,
+    '.zip': ZipArchive,
+}

docs/man/django-admin.1

@@ -99,8 +99,7 @@ Prints the DROP TABLE SQL statements for the given app name(s).
 Prints the custom SQL statements for the given app name(s).
 .TP
 .BI "sqlflush [" "appname ..." "]"
-Prints the SQL statements that would be executed for the "flush" 
-command.
+Prints the SQL statements that would be executed for the "flush" command.
 .TP
 .BI "sqlindexes [" "appname ..." "]"
 Prints the CREATE INDEX SQL statements for the given model module name(s).
@@ -116,13 +115,13 @@ name(s).
 Prints the SQL statements for resetting PostgreSQL sequences for the
 given app name(s).
 .TP
-.BI "startapp [" "appname" "]"
+.BI "startapp [" "\-\-template=PATH_OR_URL" "] [" "\-\-extension=EXTENSION" "] [" "appname" "] [" "destination" "]"
 Creates a Django app directory structure for the given app name in
-the current directory.
+the current directory or the optional destination.
 .TP
-.BI "startproject [" "projectname" "]"
+.BI "startproject [" "\-\-template=PATH_OR_URL" "] [" "\-\-extension=EXTENSION" "] [" "projectname" "] [" "destination" "]"
 Creates a Django project directory structure for the given project name
-in the current directory.
+in the current directory or the optional destination.
 .TP
 .BI syncdb
 Creates the database tables for all apps in INSTALLED_APPS whose tables
@@ -194,7 +193,7 @@ The locale to process when using makemessages or compilemessages.
 The domain of the message files (default: "django") when using makemessages.
 .TP
 .I \-e, \-\-extension=EXTENSION
-The file extension(s) to examine (default: ".html", separate multiple
+The file extension(s) to examine (separate multiple
 extensions with commas, or use -e multiple times).
 .TP
 .I \-s, \-\-symlinks
@@ -214,6 +213,9 @@ Don't break long message lines into several lines.
 .I \-a, \-\-all
 Process all available locales when using makemessages..SH "ENVIRONMENT"
 .TP
+.I \-a, \-\-template=PATH_OR_URL
+The file or directory path or URL to load the project and app templates from.
+.TP
 .I DJANGO_SETTINGS_MODULE
 In the absence of the
 .BI \-\-settings

docs/ref/django-admin.txt

@@ -907,21 +907,121 @@ of sync with its automatically incremented field data.
 The :djadminopt:`--database` option can be used to specify the database for
 which to print the SQL.
 
-startapp <appname>
-------------------
+startapp <appname> [destination]
+--------------------------------
 
 .. django-admin:: startapp
 
 Creates a Django app directory structure for the given app name in the current
+directory or the given destination.
+
+.. versionchanged:: 1.4
+
+By default the directory created contains a ``models.py`` file and other app
+template files, see the `source`_ for more details. If only the app
+name is given, the app directory will be created in the current working
 directory.
 
-startproject <projectname>
---------------------------
+If the optional destination is provided, it will be used to create the
+the new app directory in. The use of '.' to denote the current working
+directory is valid for the destination. For example::
+
+    django-admin.py startapp myapp /Users/jezdez/Code
+
+
+.. versionadded:: 1.4
+.. django-admin-option:: --template
+
+With the ``--template`` option you can use a custom app template by providing
+either the path to a directory with the app template file, a path to a
+compressed file (``.tar.gz``, ``.tar.bz2``, ``.tgz``, ``.tbz``, ``.zip``)
+containing the app template files.
+
+Additionally Django will also accept URLs (``http``, ``https``, ``ftp``) to
+compressed archives with the app template files, downloading and extracting
+them on the fly.
+
+For example, this would look for an app template in the given directory when creating the ``myapp`` app::
+
+    django-admin.py startapp --template=/Users/jezdez/Code/my_app_template myapp
+
+.. versionadded:: 1.4
+
+When Django copies the app template files it will also render the files
+whose extension matches those passed with the ``--extension`` option (``py``
+by default) using the template engine. The :class:`template context
+<django.template.Context>` used is:
+
+- Any option passed to the startapp command
+- ``app_name`` -- the appp name as passed to the command
+- ``app_directory`` -- the full path of the newly created app
+
+.. _render_warning:
+
+.. warning::
+
+    When the app template files are rendered with the Django template
+    engine (by default all ``*.py`` files) it will also replace all
+    stray template variables contained. If one of the Python files for
+    example contains a docstring explaining a particular feature related
+    to template rendering, it might result in an incorrect example.
+
+    To work around this problem you can use the :ttag:`templatetag`
+    templatetag to "escape" the various parts of the template syntax.
+
+.. _source: https://code.djangoproject.com/browser/django/trunk/django/conf/app_template/
+
+startproject <projectname> [destination]
+----------------------------------------
 
 .. django-admin:: startproject
 
-Creates a Django project directory structure for the given project name in the
-current directory.
+Creates a Django project directory structure for the given project name in
+the current directory or the given destination.
+
+.. versionchanged:: 1.4
+
+By default the directory created contains a ``manage.py`` file and a project
+package (containing ``settings.py`` file and other project template files),
+see the `template source`_ for more details.
+
+If only the project name is given, both the project directory and project
+package will be named ``<projectname>`` and the project directory
+will be created in the current working directory.
+
+If the optional destination is provided, it will be used to create the
+the new project directory in. The use of '.' to denote the current working
+directory is valid for the destination. For example::
+
+    django-admin.py startproject myproject /Users/jezdez/Code
+
+.. versionadded:: 1.4
+
+Similar to the :djadmin:`startapp` command the ``--template`` option is also
+available for specifying a directory or file path of a custom project
+template. See the :djadmin:`startapp` documentation for details of supported
+project template formats.
+
+For example, this would look for a project template in the given directory
+when creating the ``myproject`` project::
+
+    django-admin.py startproject --template=/Users/jezdez/Code/my_project_template myproject
+
+When Django copies the project template files it will also render the files
+whose extension matches those passed with the ``--extension`` option (``py``
+by default) using the template engine. The :class:`template context
+<django.template.Context>` used is:
+
+- Any option passed to the startproject command
+- ``project_name`` -- the project name as passed to the command
+- ``project_directory`` -- the full path of the newly created project
+- ``secret_key`` -- a random key for the :setting:`SECRET_KEY` setting
+
+Please also see the :ref:`rendering warning <render_warning>` as mentioned
+for :djadmin:`startapp`.
+
+.. _`template source`: https://code.djangoproject.com/browser/django/trunk/django/conf/project_template/
+
 
 syncdb
 ------

docs/releases/1.4-alpha-1.txt

@@ -429,6 +429,27 @@ callable :djadmin:`runserver` uses.
 (The :djadmin:`runfcgi` management command also internally wraps the WSGI
 callable configured via :setting:`WSGI_APPLICATION`.)
 
+Custom project and app templates
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The :djadmin:`startapp` and :djadmin:`startproject` management commands
+got a ``--template`` option for specifying paths or URL to custom app or
+project templates.
+
+For example, Django will use the ``/path/to/my_project_template``
+directorywhen running the following command::
+
+    django-admin.py startproject --template=/path/to/my_project_template myproject
+
+Additionally you can now provide a destination directory as the second
+argument to both :djadmin:`startapp` and :djadmin:`startproject`::
+
+    django-admin.py startapp myapp /path/to/new/app
+    django-admin.py startproject myproject /path/to/new/project
+
+For more information see the :djadmin:`startapp` and :djadmin:`startproject`
+documentation.
+
 Support for time zones
 ~~~~~~~~~~~~~~~~~~~~~~
 

docs/releases/1.4.txt

@@ -420,6 +420,27 @@ callable :djadmin:`runserver` uses.
 (The :djadmin:`runfcgi` management command also internally wraps the WSGI
 callable configured via :setting:`WSGI_APPLICATION`.)
 
+Custom project and app templates
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The :djadmin:`startapp` and :djadmin:`startproject` management commands
+got a ``--template`` option for specifying paths or URL to custom app or
+project templates.
+
+For example, Django will use the ``/path/to/my_project_template``
+directorywhen running the following command::
+
+    django-admin.py startproject --template=/path/to/my_project_template myproject
+
+Additionally you can now provide a destination directory as the second
+argument to both :djadmin:`startapp` and :djadmin:`startproject`::
+
+    django-admin.py startapp myapp /path/to/new/app
+    django-admin.py startproject myproject /path/to/new/project
+
+For more information see the :djadmin:`startapp` and :djadmin:`startproject`
+documentation.
+
 Support for time zones
 ~~~~~~~~~~~~~~~~~~~~~~
 

tests/regressiontests/admin_scripts/custom_templates/app_template/api.py

+# your API code
\ No newline at end of file

tests/regressiontests/admin_scripts/custom_templates/app_template/models.py

+# whatever
\ No newline at end of file

tests/regressiontests/admin_scripts/custom_templates/project_template/additional_dir/additional_file.py

+# some file for {{ project_name }} test project
\ No newline at end of file

tests/regressiontests/admin_scripts/custom_templates/project_template/manage.py

+# The manage.py of the {{ project_name }} test project
\ No newline at end of file

tests/regressiontests/admin_scripts/custom_templates/project_template/project_name/settings.py

+# Django settings for {{ project_name }} test project.

tests/regressiontests/admin_scripts/urls.py

+import os
+from django.conf.urls import patterns
+
+here = os.path.dirname(__file__)
+
+urlpatterns = patterns('',
+    (r'^custom_templates/(?P<path>.*)$', 'django.views.static.serve', {
+        'document_root': os.path.join(here, 'custom_templates'),
+    }),
+)

tests/regressiontests/utils/archive.py

+import os
+import shutil
+import tempfile
+from django.utils import unittest
+
+from django.utils.archive import Archive, extract
+
+
+TEST_DIR = os.path.join(os.path.dirname(__file__), 'archives')
+
+
+class ArchiveTester(object):
+    archive = None
+
+    def setUp(self):
+        """
+        Create temporary directory for testing extraction.
+        """
+        self.old_cwd = os.getcwd()
+        self.tmpdir = tempfile.mkdtemp()
+        self.addCleanup(shutil.rmtree, self.tmpdir)
+        self.archive_path = os.path.join(TEST_DIR, self.archive)
+        # Always start off in TEST_DIR.
+        os.chdir(TEST_DIR)
+
+    def tearDown(self):
+        os.chdir(self.old_cwd)
+
+    def test_extract_method(self):
+        Archive(self.archive).extract(self.tmpdir)
+        self.check_files(self.tmpdir)
+
+    def test_extract_method_no_to_path(self):
+        os.chdir(self.tmpdir)
+        Archive(self.archive_path).extract()
+        self.check_files(self.tmpdir)
+
+    def test_extract_function(self):
+        extract(self.archive_path, self.tmpdir)
+        self.check_files(self.tmpdir)
+
+    def test_extract_function_no_to_path(self):
+        os.chdir(self.tmpdir)
+        extract(self.archive_path)
+        self.check_files(self.tmpdir)
+
+    def check_files(self, tmpdir):
+        self.assertTrue(os.path.isfile(os.path.join(self.tmpdir, '1')))
+        self.assertTrue(os.path.isfile(os.path.join(self.tmpdir, '2')))
+        self.assertTrue(os.path.isfile(os.path.join(self.tmpdir, 'foo', '1')))
+        self.assertTrue(os.path.isfile(os.path.join(self.tmpdir, 'foo', '2')))
+        self.assertTrue(os.path.isfile(os.path.join(self.tmpdir, 'foo', 'bar', '1')))
+        self.assertTrue(os.path.isfile(os.path.join(self.tmpdir, 'foo', 'bar', '2')))
+
+
+class TestZip(ArchiveTester, unittest.TestCase):
+    archive = 'foobar.zip'
+
+
+class TestTar(ArchiveTester, unittest.TestCase):
+    archive = 'foobar.tar'
+
+
+class TestGzipTar(ArchiveTester, unittest.TestCase):
+    archive = 'foobar.tar.gz'
+
+
+class TestBzip2Tar(ArchiveTester, unittest.TestCase):
+    archive = 'foobar.tar.bz2'

tests/regressiontests/utils/tests.py

@@ -24,3 +24,4 @@ from .baseconv import TestBaseConv
 from .jslex import JsTokensTest, JsToCForGettextTest
 from .ipv6 import TestUtilsIPv6
 from .timezone import TimezoneTests
+from .archive import TestZip, TestTar, TestGzipTar, TestBzip2Tar

tests/urls.py

@@ -27,4 +27,7 @@ urlpatterns = patterns('',
     # admin custom URL tests
     (r'^custom_urls/', include('regressiontests.admin_custom_urls.urls')),
 
+    # admin custom URL tests
+    (r'^admin_scripts/', include('regressiontests.admin_scripts.urls')),
+
 )