Extension plugins

example_extensions/hello_cmd/README.md

@@ -0,0 +1,12 @@
+Welcome to install your first rez extension!
+
+Currently, please pip install this Python package into Rez's venv, and run
+```
+$ rez -i
+```
+You should see a plugin named "world" in the plugin list.
+And now you could do
+```
+$ rez world -h
+```
+to see what you could do about it.

example_extensions/hello_cmd/lib.py

@@ -0,0 +1,5 @@
+
+def get_message_from_world():
+    from rez.config import config
+    message = config.plugins.command.world.message
+    return message

example_extensions/hello_cmd/rezplugins/command/rezconfig.py

@@ -0,0 +1,4 @@
+
+world = {
+    "message": "welcome to this world."
+}

example_extensions/hello_cmd/rezplugins/command/world.py

@@ -0,0 +1,37 @@
+"""
+Demoing Rez's command type plugin
+"""
+from rez.command import Command
+
+# This attribute is optional, default behavior will be applied if not present.
+command_behavior = {
+    "hidden": False,   # (bool): default False
+    "arg_mode": None,  # (str): "passthrough", "grouped", default None
+}
+
+
+def setup_parser(parser, completions=False):
+    parser.add_argument("-m", "--message", action="store_true",
+                        help="Print message from world.")
+
+
+def command(opts, parser=None, extra_arg_groups=None):
+    from hello_cmd import lib
+
+    if opts.message:
+        msg = lib.get_message_from_world()
+        print(msg)
+        return
+
+    print("Please use '-h' flag to see what you can do to this world !")
+
+
+class WorldCommand(Command):
+
+    @classmethod
+    def name(cls):
+        return "world"
+
+
+def register_plugin():
+    return WorldCommand

example_extensions/hello_cmd/setup.py

@@ -0,0 +1,12 @@
+from __future__ import print_function, with_statement
+from setuptools import setup
+
+
+setup(
+    name="hello_cmd",
+    version="1.0",
+    package_dir={"hello_cmd": ""},
+    packages=["hello_cmd",
+              "hello_cmd.rezplugins",
+              "hello_cmd.rezplugins.command"],
+)

src/rez/cli/_main.py

@@ -101,8 +101,8 @@ def setup_parser():
 
     # add lazy subparsers
     subparser = parser.add_subparsers(dest='cmd', metavar='COMMAND')
-    for subcommand in subcommands:
-        module_name = "rez.cli.%s" % subcommand
+    for subcommand, data in subcommands.items():
+        module_name = data.get('module_name', 'rez.cli.%s' % subcommand)
 
         subparser.add_parser(
             subcommand,

src/rez/cli/_util.py

@@ -63,6 +63,57 @@
 }
 
 
+def load_plugin_cmd():
+    """Load subcommand from command type plugin
+
+    The command type plugin module should have attribute `command_behavior`,
+    and the value must be a dict if provided. For example:
+
+        # in your command plugin module
+        command_behavior = {
+            "hidden": False,   # (bool): default False
+            "arg_mode": None,  #  (str): "passthrough", "grouped", default None
+        }
+
+    If the attribute not present, default behavior will be given.
+
+    """
+    from rez.config import config
+    from rez.utils.logging_ import print_debug
+    from rez.plugin_managers import plugin_manager
+
+    ext_plugins = dict()
+
+    for plugin_name in plugin_manager.get_plugins("command"):
+        module = plugin_manager.get_plugin_module("command", plugin_name)
+
+        behavior = getattr(module, "command_behavior", None)
+        if behavior is None:
+            behavior = dict()
+
+            if config.debug("plugins"):
+                print_debug("Attribute 'command_behavior' not found in plugin "
+                            "module %s, registering with default behavior."
+                            % module.__name__)
+        try:
+            data = behavior.copy()
+            data.update({"module_name": module.__name__})
+            ext_plugins[plugin_name] = data
+
+        except Exception:
+            if config.debug("plugins"):
+                import traceback
+                from rez.vendor.six.six import StringIO
+                out = StringIO()
+                traceback.print_exc(file=out)
+                print_debug(out.getvalue())
+
+    return ext_plugins
+
+
+subcommands.update(load_plugin_cmd())
+
+
 class LazySubParsersAction(_SubParsersAction):
     """Argparse Action which calls the `setup_subparser` function provided to
     `LazyArgumentParser`.

src/rez/cli/complete.py

@@ -80,7 +80,8 @@ def _pop_arg(l, p):
 
     # create parser for subcommand
     from rez.backport.importlib import import_module
-    module_name = "rez.cli.%s" % subcommand
+    data = subcommands[subcommand]
+    module_name = data.get("module_name", "rez.cli.%s" % subcommand)
     mod = import_module(module_name)
     parser = argparse.ArgumentParser()
     mod.setup_parser(parser, completions=True)

src/rez/command.py

@@ -0,0 +1,52 @@
+
+from rez.config import config
+
+
+class Command(object):
+    """An interface for registering custom Rez subcommand
+
+    To register plugin and expose subcommand, the plugin module..
+
+    * MUST have a module-level docstring (used as the command help)
+    * MUST provide a `setup_parser()` function
+    * MUST provide a `command()` function
+    * MUST provide a `register_plugin()` function
+    * SHOULD have a module-level attribute `command_behavior`
+
+    For example, a plugin named 'foo' and this is the `foo.py`:
+
+        '''The docstring for command help, this is required.
+        '''
+        from rez.command import Command
+
+        command_behavior = {
+            "hidden": False,   # optional: bool
+            "arg_mode": None,  # optional: None, "passthrough", "grouped"
+        }
+
+        def setup_parser(parser, completions=False):
+            parser.add_argument("--hello", ...)
+
+        def command(opts, parser=None, extra_arg_groups=None):
+            if opts.hello:
+                print("world")
+
+        class CommandFoo(Command):
+            schema_dict = {}
+
+            @classmethod
+            def name(cls):
+                return "foo"
+
+        def register_plugin():
+            return CommandFoo
+
+    """
+    def __init__(self):
+        self.type_settings = config.plugins.extension
+        self.settings = self.type_settings.get(self.name())
+
+    @classmethod
+    def name(cls):
+        """Return the name of the Command and rez-subcommand."""
+        raise NotImplementedError

src/rez/data/tests/extensions/bar/rezplugins/package_repository/memory.py

@@ -0,0 +1,13 @@
+
+from rez.package_repository import PackageRepository
+
+
+class MemoryPackageRepository(PackageRepository):
+    @classmethod
+    def name(cls):
+        return "memory"
+    on_test = "bar"
+
+
+def register_plugin():
+    return MemoryPackageRepository

src/rez/data/tests/extensions/foo/rezplugins/package_repository/cloud.py

@@ -0,0 +1,12 @@
+
+from rez.package_repository import PackageRepository
+
+
+class CloudPackageRepository(PackageRepository):
+    @classmethod
+    def name(cls):
+        return "cloud"
+
+
+def register_plugin():
+    return CloudPackageRepository

src/rez/data/tests/extensions/non-mod/rezplugins/package_repository/memory.py

@@ -0,0 +1,13 @@
+
+from rez.package_repository import PackageRepository
+
+
+class MemoryPackageRepository(PackageRepository):
+    @classmethod
+    def name(cls):
+        return "memory"
+    on_test = "non-mod"
+
+
+def register_plugin():
+    return MemoryPackageRepository