support for mutipage-shim

require/conf.py

@@ -40,5 +40,9 @@ def REQUIRE_ENVIRONMENT_ALIASES(self):
             'node': 'require.environments.NodeEnvironment',
             'rhino': 'require.environments.RhinoEnvironment',
             })
+
+    @property
+    def REQUIRE_COMMON_MODULE(self):
+        return getattr(django_settings, "REQUIRE_COMMON_MODULE", {})
 
 settings = LazySettings()

require/helpers.py

@@ -4,6 +4,7 @@
 from django.utils.importlib import import_module
 
 from require.conf import settings as require_settings
+from django.contrib.staticfiles.storage import staticfiles_storage
 
 
 
@@ -21,4 +22,12 @@ def resolve_require_url(name):
 def resolve_require_module(name):
     if not posixpath.splitext(name)[-1].lower() == ".js":
         name += ".js"
-    return resolve_require_url(name)
+    return resolve_require_url(name)
+
+
+def resolve_require_module_hash(module):
+    module_hash_name = staticfiles_storage.url(resolve_require_module(module)).split("/")[-1].replace('.js', '')
+    module_path = module.split("/")
+    module_path[-1]=module_hash_name
+    module_name = "/".join(module_path)
+    return module_name

require/storage.py

@@ -40,13 +40,28 @@ def run_optimizer(self, *args, **kwargs):
         compiler_args.extend(args)
         if self.verbosity == 0:
             kwargs.setdefault("logLevel", "4")
+
+        #convert kwargs with list value to arg with comma sep list.
+        kwargs_to_args = []
+        for key, value in kwargs.items():
+            if key == 'common_module_args':
+                kwargs_to_args+=value
+                kwargs.pop(key)
+            elif type(value) == list:
+                kwargs_to_args.append(key+"="+",".join(value))
+                kwargs.pop(key)
+            if not value:
+                kwargs.pop(key)
+
         compiler_args.extend(
             "{0}={1}".format(
                 key, value
             )
             for key, value
             in kwargs.items()
         )
+        compiler_args.extend(kwargs_to_args)
+
         # Run the compiler in a subprocess.
         if subprocess.call(compiler_args) != 0:
             raise OptimizationError("Error while running r.js optimizer.")
@@ -71,6 +86,41 @@ class OptimizedFilesMixin(object):
     def _file_iter(self, handle):
         return iter(partial(handle.read, self.REQUIRE_COPY_BLOCK_SIZE), b'')
 
+    def optimize_single_file(self,env, module, config, name):
+        if "out" in config:
+            if "build_profile" in config:
+                module_build_js_path = env.compile_dir_path(config["build_profile"])
+            else:
+                module_build_js_path = env.resource_path("module.build.js")
+            #need to add common.build.js above?
+            if name == 'almond':
+                include = [module]
+            else:
+                include = ['requireLib']
+            if "include" in config:
+                include = include+config["include"]
+            exclude = False
+            if "exclude" in config:
+                exclude = config["exclude"]
+            #end add
+            optimizer_kwargs = {"name": name,
+                                "include": include,
+                                "exclude": exclude,
+                                "out": env.build_dir_path(config["out"]),
+                                "baseUrl": os.path.join(env.compile_dir, require_settings.REQUIRE_BASE_URL)
+                                }
+
+            # Catch common module and add kwarg to optimizer_kwargs
+            if name is not 'almond':
+                optimizer_kwargs.update({"paths.requireLib":require_settings.REQUIRE_JS.replace('.js', '')})
+
+
+            env.run_optimizer(module_build_js_path,**optimizer_kwargs)
+        else:
+            raise ImproperlyConfigured(u"No 'out' option specified for module '{module}' in REQUIRE_STANDALONE_MODULES setting.".format(
+                module = module
+            ))
+
     def post_process(self, paths, dry_run=False, verbosity=1, **options):
         # If this is a dry run, give up now!
         if dry_run:
@@ -101,36 +151,39 @@ def post_process(self, paths, dry_run=False, verbosity=1, **options):
                     app_build_js_path = env.compile_dir_path(require_settings.REQUIRE_BUILD_PROFILE)
                 else:
                     app_build_js_path = env.resource_path("app.build.js")
-                env.run_optimizer(
-                    app_build_js_path,
-                    dir = env.build_dir,
-                    appDir = env.compile_dir,
-                    baseUrl = require_settings.REQUIRE_BASE_URL,
+
+                optimizer_kwargs = {'dir': env.build_dir,
+                                'appDir': env.compile_dir,
+                                'baseUrl': require_settings.REQUIRE_BASE_URL}
+
+                env.run_optimizer(app_build_js_path, **optimizer_kwargs)
+
+            # Catch & compile common module
+            common_keys = require_settings.REQUIRE_COMMON_MODULE.keys()
+            if len(common_keys)>1:
+                raise ImproperlyConfigured('You may only specify one common module in REQUIRE_COMMON_MODULE'
+                                           'any additional modules should be specified in your app.build.js')
+
+            if common_keys:
+                shutil.copyfile(
+                    env.resource_path("require.js"),
+                    env.compile_dir_path("require.js"),
                 )
+
+            for common_module, common_config in require_settings.REQUIRE_COMMON_MODULE.items():
+                self.optimize_single_file(env, common_module, common_config, common_keys[0])
+
             # Compile standalone modules.
             if require_settings.REQUIRE_STANDALONE_MODULES:
                 shutil.copyfile(
                     env.resource_path("almond.js"),
                     env.compile_dir_path("almond.js"),
                 )
                 exclude_names.append(resolve_require_url("almond.js"))
+
             for standalone_module, standalone_config in require_settings.REQUIRE_STANDALONE_MODULES.items():
-                if "out" in standalone_config:
-                    if "build_profile" in standalone_config:
-                        module_build_js_path = env.compile_dir_path(standalone_config["build_profile"])
-                    else:
-                        module_build_js_path = env.resource_path("module.build.js")
-                    env.run_optimizer(
-                        module_build_js_path,
-                        name = "almond",
-                        include = standalone_module,
-                        out = env.build_dir_path(standalone_config["out"]),
-                        baseUrl = os.path.join(env.compile_dir, require_settings.REQUIRE_BASE_URL),
-                    )
-                else:
-                    raise ImproperlyConfigured("No 'out' option specified for module '{module}' in REQUIRE_STANDALONE_MODULES setting.".format(
-                        module = standalone_module
-                    ))
+                self.optimize_single_file(env,standalone_module,standalone_config, 'almond')
+
             # Update assets with modified ones.
             compiled_storage = FileSystemStorage(env.build_dir)
             # Walk the compiled directory, checking for modified assets.

require/templatetags/require.py

@@ -5,26 +5,76 @@
 from django.contrib.staticfiles.storage import staticfiles_storage
 
 from require.conf import settings as require_settings
-from require.helpers import resolve_require_url, resolve_require_module
+from require.helpers import resolve_require_url, resolve_require_module, resolve_require_module_hash
 
 
 register = template.Library()
 
 
 @register.simple_tag
-def require_module(module):
+def require_module(module, mode=None):
     """
     Inserts a script tag to load the named module, which is relative to the REQUIRE_BASE_URL setting.
 
     If the module is configured in REQUIRE_STANDALONE_MODULES, and REQUIRE_DEBUG is False, then
     then the standalone built version of the module will be loaded instead, bypassing require.js
     for extra load performance.
+
+    If your require.config uses shimed modules, set mode='shim'.  
+    - If the module is configured in REQUIRE_COMMON_MODULE, and REQUIRE_DEBUG is False, then then the 
+    common module will be loaded with requirejs embedded, bypassing an additional load of require.js 
+    for extra load performance.
+    - If the specified module does not match REQUIRE_COMMON_MODULE and REQUIRE_DEBUG is False a script
+    tag will be inserted requireing the specified module.  If REQUIRE_DEBUG is True, a script tag will 
+    be inserted requireing the common module with a nested require call of the specified module.
     """
-    if not require_settings.REQUIRE_DEBUG and module in require_settings.REQUIRE_STANDALONE_MODULES:
-        return """<script src="{module}"></script>""".format(
-            module = staticfiles_storage.url(resolve_require_module(require_settings.REQUIRE_STANDALONE_MODULES[module]["out"])),
-        )
-    return """<script src="{src}" data-main="{module}"></script>""".format(
+    if not require_settings.REQUIRE_DEBUG:
+        if module in require_settings.REQUIRE_STANDALONE_MODULES:
+            string = u"""<script src="{module}"></script>""".format(
+                module = staticfiles_storage.url(resolve_require_module(require_settings.REQUIRE_STANDALONE_MODULES[module]["out"])))
+        elif module in require_settings.REQUIRE_COMMON_MODULE:
+            # Load common (Assume requirejs is included with common)
+            string = u"""<script src="{common}"></script>""".format(
+                common = staticfiles_storage.url(resolve_require_module(require_settings.REQUIRE_COMMON_MODULE[module]["out"])))
+        else:
+            # Load additional modules (Assume that requirejs is accessible)
+            string = u"""<script>require(['{module}']);</script>""".format(
+                module = resolve_require_module_hash(module))
+        return string
+
+    elif require_settings.REQUIRE_COMMON_MODULE:
+            common_keys = require_settings.REQUIRE_COMMON_MODULE.keys()
+            common_module = common_keys[0]
+            # The specified module is the common module
+            if module in require_settings.REQUIRE_COMMON_MODULE:
+                if mode == 'shim':
+                    # Requirejs and shim common module
+                    string = u"""<script src="{requirejs}"></script>""".format(
+                        requirejs = staticfiles_storage.url(resolve_require_url(require_settings.REQUIRE_JS)))
+                    string += u"""<script>require(['{common}']);</script>""".format(
+                        common = staticfiles_storage.url(resolve_require_module(common_module)))
+                else:
+                    # Requirejs and data-main common module
+                    string = u"""<script src="{requirejs}" data-main="{common}"></script>""".format(
+                        requirejs = staticfiles_storage.url(resolve_require_url(require_settings.REQUIRE_JS)),
+                        common = staticfiles_storage.url(resolve_require_module(common_module)))
+            # The specified module is not the common module (assume common has already been loaded)
+            elif mode == 'shim':
+                # Require common and nest a require for the specified module
+                string = u"""<script>require(['{common}'], function () {{""".format(
+                    common = staticfiles_storage.url(resolve_require_module(common_module)))
+                string += u"""require(['{module}']);""".format(
+                    module = resolve_require_module_hash(module))
+                string += u"""});</script>"""
+            # Non shim mode template inheritance
+            else:
+                # Just require the specified module
+                string = u"""<script>require(['{module}']);</script>""".format(
+                    module = resolve_require_module_hash(module))
+
+            return string
+
+    return u"""<script src="{src}" data-main="{module}"></script>""".format(
         src = staticfiles_storage.url(resolve_require_url(require_settings.REQUIRE_JS)),
         module = staticfiles_storage.url(resolve_require_module(module)),
-    )
+                )