Switch to explicit static folders

Author: mitsuhiko

flask/app.py

@@ -11,6 +11,7 @@
 
 from __future__ import with_statement
 
+import os
 from threading import Lock
 from datetime import timedelta, datetime
 from itertools import chain
@@ -90,9 +91,9 @@ class Flask(_PackageBoundObject):
 
     :param import_name: the name of the application package
     :param static_path: can be used to specify a different path for the
-                        static files on the web.  Defaults to ``/static``.
-                        This does not affect the folder the files are served
-                        *from*.
+                        static folder.  Defaults to ``'static'``.  Setting
+                        this to `None` disables the default folder for
+                        static files.
     """
 
     #: The class that is used for request objects.  See :class:`~flask.Request`
@@ -103,14 +104,6 @@ class Flask(_PackageBoundObject):
     #: :class:`~flask.Response` for more information.
     response_class = Response
 
-    #: Path for the static files.  If you don't want to use static files
-    #: you can set this value to `None` in which case no URL rule is added
-    #: and the development server will no longer serve any static files.
-    #:
-    #: This is the default used for application and modules unless a
-    #: different value is passed to the constructor.
-    static_path = '/static'
-
     #: The debug flag.  Set this to `True` to enable debugging of the
     #: application.  In debug mode the debugger will kick in when an unhandled
     #: exception ocurrs and the integrated server will automatically reload
@@ -198,10 +191,8 @@ class Flask(_PackageBoundObject):
         'MAX_CONTENT_LENGTH':                   None
     })
 
-    def __init__(self, import_name, static_path=None):
-        _PackageBoundObject.__init__(self, import_name)
-        if static_path is not None:
-            self.static_path = static_path
+    def __init__(self, import_name, static_path='static'):
+        _PackageBoundObject.__init__(self, import_name, static_path)
 
         #: The configuration dictionary as :class:`Config`.  This behaves
         #: exactly like a regular dictionary but supports additional methods
@@ -273,14 +264,13 @@ def __init__(self, import_name, static_path=None):
         #:    app.url_map.converters['list'] = ListConverter
         self.url_map = Map()
 
-        # register the static folder for the application.  Do that even
-        # if the folder does not exist.  First of all it might be created
-        # while the server is running (usually happens during development)
-        # but also because google appengine stores static files somewhere
-        # else when mapped with the .yml file.
-        self.add_url_rule(self.static_path + '/<path:filename>',
-                          endpoint='static',
-                          view_func=self.send_static_file)
+        # register the static folder for the application if necessary.
+        # The basename of the static path is the URL prefix.
+        if self.static_path is not None:
+            self.add_url_rule('/%s/<path:filename>' %
+                              os.path.basename(self.static_path),
+                              endpoint='static',
+                              view_func=self.send_static_file)
 
         #: The Jinja2 environment.  It is created from the
         #: :attr:`jinja_options`.

flask/helpers.py

@@ -429,22 +429,38 @@ def _get_package_path(name):
 
 class _PackageBoundObject(object):
 
-    def __init__(self, import_name):
+    def __init__(self, import_name, static_path=None):
         #: The name of the package or module.  Do not change this once
         #: it was set by the constructor.
         self.import_name = import_name
 
         #: Where is the app root located?
         self.root_path = _get_package_path(self.import_name)
 
+        if static_path is not None:
+            static_path = os.path.join(self.root_path, static_path)
+
+        #: the path to the static files or None if this object does
+        #: not export any static files under a standard name.
+        self.static_path = static_path
+
     @property
     def has_static_folder(self):
         """This is `True` if the package bound object's container has a
         folder named ``'static'``.
 
         .. versionadded:: 0.5
+
+        .. versionchanged:: 0.7
+           This propery got deprecated because it is unreliable under
+           certain hosting setups such as Google's Appengine.  This will
+           be gone in Flask 1.0
         """
-        return os.path.isdir(os.path.join(self.root_path, 'static'))
+        from warnings import warn
+        warn(DeprecationWarning('has_static_folder is deprecated.  Pass '
+            'explicitly a static path now if you want a default static '
+            'folder for an application or module.'), stacklevel=2)
+        return os.path.isdir(self.static_path)
 
     @cached_property
     def jinja_loader(self):
@@ -460,8 +476,7 @@ def send_static_file(self, filename):
 
         .. versionadded:: 0.5
         """
-        return send_from_directory(os.path.join(self.root_path, 'static'),
-                                   filename)
+        return send_from_directory(self.static_path, filename)
 
     def open_resource(self, resource):
         """Opens a resource from the application's resource folder.  To see
@@ -482,6 +497,10 @@ def open_resource(self, resource):
                 contents = f.read()
                 do_something_with(contents)
 
+        Note that on Google Appengine static files are deployed to an entirely
+        different server with a proper app.yml and because of that, this method
+        is unable to open static files on such an environment.
+
         :param resource: the name of the resource.  To access resources within
                          subfolders use forward slashes as separator.
         """

flask/module.py

@@ -9,24 +9,36 @@
     :license: BSD, see LICENSE for more details.
 """
 
+import os
 from .helpers import _PackageBoundObject, _endpoint_from_view_func
 
 
-def _register_module(module, static_path):
+def _register_module(module):
     """Internal helper function that returns a function for recording
     that registers the `send_static_file` function for the module on
     the application if necessary.  It also registers the module on
     the application.
     """
     def _register(state):
         state.app.modules[module.name] = module
-        # do not register the rule if the static folder of the
-        # module is the same as the one from the application.
-        if state.app.root_path == module.root_path:
-            return
-        path = static_path
+        path = module.static_path
+        # XXX: backwards compatibility.  This will go away in 1.0
+        if path is None and module._backwards_compat_static_path:
+            path = module.static_path
+            if path == app.static_path:
+                return
+            from warnings import warn
+            warn(DeprecationWarning('With Flask 0.7 the static folder '
+                'for modules became explicit due to problems with the '
+                'existing system on Google Appengine and multiple '
+                'modules with the same prefix.\n'
+                'Pass ``static_path=\'static\'`` to the Module '
+                'constructor if you want to use static folders.\n'
+                'This backwards compatibility support will go away in '
+                'Flask 1.0'), stacklevel=3)
         if path is None:
-            path = state.app.static_path
+            return
+        path = '/' + os.path.basename(path)
         if state.url_prefix:
             path = state.url_prefix + path
         state.app.add_url_rule(path + '/<path:filename>',
@@ -112,18 +124,27 @@ def login():
                         This does not affect the folder the files are served
                         *from*.
     """
+    _backwards_compat_static_path = False
 
     def __init__(self, import_name, name=None, url_prefix=None,
                  static_path=None, subdomain=None):
         if name is None:
             assert '.' in import_name, 'name required if package name ' \
                 'does not point to a submodule'
             name = import_name.rsplit('.', 1)[1]
-        _PackageBoundObject.__init__(self, import_name)
+        _PackageBoundObject.__init__(self, import_name, static_path)
         self.name = name
         self.url_prefix = url_prefix
         self.subdomain = subdomain
-        self._register_events = [_register_module(self, static_path)]
+        self._register_events = [_register_module(self)]
+
+        # XXX: backwards compatibility, see _register_module.  This
+        # will go away in 1.0
+        if self.static_path is None:
+            path = os.path.join(self.root_path, 'static')
+            if os.path.isdir(path):
+                self.static_path = path
+                self._backwards_compat_static_path = True
 
     def route(self, rule, **options):
         """Like :meth:`Flask.route` but for a module.  The endpoint for the

tests/moduleapp/apps/admin/__init__.py

@@ -1,7 +1,8 @@
+import os
 from flask import Module, render_template
 
 
-admin = Module(__name__, url_prefix='/admin')
+admin = Module(__name__, url_prefix='/admin', static_path='static')
 
 
 @admin.route('/')