Merge pull request #1709 from dapomeroy/report_format_lines

Allow namespaced specs

Author: douglasjacobsen

lib/ramble/docs/dev_guides/shared/repository_create.rst

@@ -82,3 +82,30 @@ when multiple exist with the same name. Each repository has a namespace, and
 these namespaces can be used to refer to specific instances of each object
 definition.
 
+Referencing Objects with Namespaces
+-----------------------------------
+
+When multiple repositories contain objects with the same name, or when you want
+to be explicit about which repository an object comes from, you can use fully-qualified
+namespaced specs.
+
+Namespaced specs take the form:
+
+* ``<namespace>.<object_name>`` (e.g., ``tutorial-repo.hostname``, ``builtin.wrf``)
+* ``<namespace>.<type_abbrev>.<object_name>`` (e.g., ``tutorial-repo.app.hostname``, ``builtin.mod.my_modifier``)
+* ``<namespace>.<type_abbrev>.<object_name>@<version>`` (e.g., ``builtin.app.wrf@4.2``, ``builtin.app.wrf@{version}``)
+
+Common object type abbreviations include:
+
+* ``app`` or ``application`` for applications
+* ``mod`` or ``modifier`` for modifiers
+* ``pkg_man`` or ``package_manager`` for package managers
+* ``wm`` or ``workflow_manager`` for workflow managers
+* ``sys`` or ``system`` for systems
+* ``plat`` or ``platform`` for platforms
+
+Base objects can be referenced with the ``base_<type_abbrev>`` prefix.
+
+These namespaced specs can be used in CLI commands (e.g., ``ramble info <spec>``,
+``ramble edit <spec>``, ``ramble create <spec>``) and in workspace configuration files
+(``ramble.yaml``) under the ``applications:`` and ``environments:`` sections.

lib/ramble/docs/workspace_config.rst

@@ -93,7 +93,9 @@ In the above example, the experiment name would be: ``test_1_1`` when it is crea
 
 **NOTE:** Each experiment has a namespace that follows this pattern:
 ``application.workload.experiment``. Every experiment needs a unique namespace,
-or ramble will throw an error.
+or ramble will throw an error. Application entries can be specified with short names
+(e.g., ``hostname``), fully qualified namespaced specs (e.g., ``builtin.app.hostname``),
+or with version suffixes (e.g., ``builtin.app.wrf@{version}`` or ``wrf@4.2``).
 
 .. _variable-dictionaries:
 

lib/ramble/ramble/cmd/common/info.py

@@ -13,6 +13,7 @@
 from llnl.util.tty.colify import colified
 
 import ramble.repository
+import ramble.spec
 import ramble.util.colors as color
 from ramble.cmd.common import arguments
 from ramble.definitions.variables import Variable
@@ -78,7 +79,13 @@ def _map_attr_name(attr):
 def setup_info_parser(subparser):
     """Create the info parser"""
 
-    subparser.add_argument("object", help="Name of object to print info for")
+    subparser.add_argument(
+        "object",
+        help=(
+            "name of object or namespaced spec to print info for "
+            "(e.g., my-app or builtin.app.my-app)"
+        ),
+    )
 
     arguments.add_common_arguments(subparser, ["obj_type"])
 
@@ -473,9 +480,13 @@ def print_info(args):
     format_type = getattr(supported_formats, args.format)
     args.format = format_type
 
-    object_type = ramble.repository.ObjectTypes[args.type]
-    obj_name = args.object
-    obj = ramble.repository.get(obj_name, object_type=object_type)
+    spec = ramble.spec.Spec(args.object)
+    if spec.object_type:
+        object_type = spec.object_type
+    else:
+        object_type = ramble.repository.ObjectTypes[args.type]
+
+    obj = ramble.repository.get(spec, object_type=object_type)
 
     print_object_header(object_type, obj)
 

lib/ramble/ramble/cmd/create.py

@@ -9,6 +9,7 @@
 
 import ramble.creator
 import ramble.repository
+import ramble.spec
 import ramble.util.naming as nm
 from ramble.util.logger import logger
 
@@ -33,8 +34,10 @@ def setup_parser(subparser):
     subparser.add_argument(
         "object_type",
         nargs="?",
-        choices=list(type_mapping.keys()),
-        help="the type of object definition to create",
+        help=(
+            "the type of object definition to create or a namespaced spec "
+            "(e.g., application, or builtin.app.foo)"
+        ),
     )
     subparser.add_argument(
         "name",
@@ -196,11 +199,33 @@ def run_interactive_wizard():
 def create(parser, args):
     """Main command runner logic."""
 
+    obj_type = None
+    name = None
+    repo = args.repo
+    base = args.base
+    maintainers = [m.strip() for m in args.maintainers.split(",")] if args.maintainers else []
+    tags = [t.strip() for t in args.tags.split(",")] if args.tags else []
+
+    if args.object_type:
+        spec = ramble.spec.Spec(args.object_type)
+        if spec.object_type and spec.name:
+            obj_type = spec.object_type
+            name = spec.name
+            if spec.namespace:
+                repo = spec.namespace
+        else:
+            type_map = ramble.repository.get_object_type_map()
+            if args.object_type in type_map:
+                obj_type = type_map[args.object_type]
+                name = args.name
+
     # Check if interactive wizard is requested or needed
-    if args.interactive or not args.object_type or not args.name:
+    if args.interactive or not obj_type or not name:
         import sys
 
         if not sys.stdin.isatty():
+            if args.object_type and not name and obj_type:
+                logger.die(f"Missing name for {args.object_type}.")
             logger.die(
                 "Interactive wizard cannot be run in a non-interactive terminal. "
                 "Please provide 'object_type' and 'name' arguments."
@@ -210,13 +235,6 @@ def create(parser, args):
         except KeyboardInterrupt:
             print("\n\n[ABORTED] Object creation cancelled.")
             return 1
-    else:
-        obj_type = type_mapping[args.object_type]
-        name = args.name
-        repo = args.repo
-        base = args.base
-        maintainers = [m.strip() for m in args.maintainers.split(",")] if args.maintainers else []
-        tags = [t.strip() for t in args.tags.split(",")] if args.tags else []
 
     try:
         file_path, repo_namespace = ramble.creator.create_object(

lib/ramble/ramble/cmd/edit.py

@@ -12,6 +12,7 @@
 import ramble.cmd
 import ramble.paths
 import ramble.repository
+import ramble.spec
 from ramble.util.logger import logger
 
 from spack.util.editor import editor
@@ -25,8 +26,8 @@ def normalize_type_name(type_name):
     if not type_name:
         return None
 
-    # Map aliases
-    aliases = {
+    # Map non-object type aliases
+    extra_type_aliases = {
         "test": "test",
         "tests": "test",
         "command": "command",
@@ -36,18 +37,14 @@ def normalize_type_name(type_name):
         "module": "module",
         "modules": "module",
     }
-    if type_name in aliases:
-        return aliases[type_name]
-
-    # Map singular to plural for ObjectTypes
-    norm_type = type_name.lower().replace("-", " ").replace("_", " ")
-    for obj_type in ramble.repository.ObjectTypes:
-        if norm_type == obj_type.name.lower().replace("_", " "):
-            return obj_type.name
-        if obj_type in ramble.repository.type_definitions:
-            singular = ramble.repository.type_definitions[obj_type]["singular"]
-            if norm_type == singular.lower().replace("_", " ").replace("-", " "):
-                return obj_type.name
+    norm_type = type_name.lower().strip().replace(" ", "_")
+    if norm_type in extra_type_aliases:
+        return extra_type_aliases[norm_type]
+
+    # Map object types using repository's get_object_type_map()
+    type_map = ramble.repository.get_object_type_map()
+    if norm_type in type_map:
+        return type_map[norm_type].name
 
     return type_name
 
@@ -65,27 +62,36 @@ def find_all_matches(name, repo_path=None, namespace=None, obj_type=None):
     extra_types = ["test", "command", "docs", "module"]
     allowed_types = ramble.repository.OBJECT_NAMES + extra_types
 
-    types_to_check = [obj_type] if obj_type else allowed_types
+    # Parse spec if name might be a namespaced spec
+    spec = ramble.spec.Spec(name)
+    spec_obj_type = spec.object_type.name if spec.object_type else None
+    spec_namespace = spec.namespace
+    spec_name = spec.name if spec.name else name
+
+    effective_obj_type = obj_type or spec_obj_type
+    types_to_check = [effective_obj_type] if effective_obj_type else allowed_types
+
+    effective_namespace = namespace or spec_namespace
 
     for t in types_to_check:
         if t in ramble.repository.OBJECT_NAMES:
             # Check object type
-            obj_type = ramble.repository.ObjectTypes[t]
+            repo_obj_type = ramble.repository.ObjectTypes[t]
             if repo_path:
                 try:
-                    repos = [ramble.repository.Repo(repo_path, object_type=obj_type)]
+                    repos = [ramble.repository.Repo(repo_path, object_type=repo_obj_type)]
                 except Exception:
                     repos = []
-            elif namespace:
+            elif effective_namespace:
                 try:
-                    repos = [ramble.repository.paths[obj_type].get_repo(namespace)]
+                    repos = [ramble.repository.paths[repo_obj_type].get_repo(effective_namespace)]
                 except Exception:
                     repos = []
             else:
-                repos = ramble.repository.paths[obj_type].repos
+                repos = ramble.repository.paths[repo_obj_type].repos
 
             for repo in repos:
-                path = repo.filename_for_object_name(name)
+                path = repo.filename_for_object_name(spec_name)
                 if os.path.isfile(path):
                     matches.append({"type": t, "path": path, "repo_namespace": repo.namespace})
         elif t in extra_types:
@@ -142,7 +148,12 @@ def setup_parser(subparser):
     excl_args.add_argument("-r", "--repo", default=None, help="path to repo to edit object in")
     excl_args.add_argument("-N", "--namespace", default=None, help="namespace of object to edit")
 
-    subparser.add_argument("object_name", nargs="?", default=None, help="object name")
+    subparser.add_argument(
+        "object_name",
+        nargs="?",
+        default=None,
+        help=("object name or namespaced spec to edit " "(e.g., my-app or builtin.app.my-app)"),
+    )
 
 
 def edit(parser, args):
@@ -206,7 +217,12 @@ def edit(parser, args):
 
         # If no matches found, reproduce the original behavior/messages:
         # 1. If type is specified/defaulted, we show type-specific "not found" messages.
-        type_name = args.type or ramble.repository.default_type.name
+        spec = ramble.spec.Spec(name)
+        spec_obj_type = spec.object_type.name if spec.object_type else None
+        type_name = args.type or spec_obj_type or ramble.repository.default_type.name
+        effective_namespace = args.namespace or spec.namespace
+        spec_name = spec.name if spec.name else name
+
         type_to_path = {
             "test": ramble.paths.test_path,
             "command": ramble.paths.command_path,
@@ -226,11 +242,11 @@ def edit(parser, args):
                 obj_type = ramble.repository.ObjectTypes[type_name]
                 if args.repo:
                     repo = ramble.repository.Repo(args.repo, object_type=obj_type)
-                elif args.namespace:
-                    repo = ramble.repository.paths[obj_type].get_repo(args.namespace)
+                elif effective_namespace:
+                    repo = ramble.repository.paths[obj_type].get_repo(effective_namespace)
                 else:
                     repo = ramble.repository.paths[obj_type]
-                path = repo.filename_for_object_name(name)
+                path = repo.filename_for_object_name(spec_name)
             except Exception:
                 path = None
 

lib/ramble/ramble/cmd/workspace.py

@@ -25,7 +25,9 @@
 import ramble.expander
 import ramble.filters
 import ramble.pipeline
+import ramble.repository
 import ramble.software_environments
+import ramble.spec
 import ramble.util.colors as color
 import ramble.workspace
 import ramble.workspace.shell
@@ -901,19 +903,42 @@ def workspace_info(args):
 
     # Build an index of experiments to avoid re-rendering them in the loops below
     experiment_index_map = defaultdict(list)
+    app_names_cache = {}
     for exp_name, app_inst, _ in experiment_set.all_experiments():
         experiment_template_name = app_inst.variables[app_inst.keywords.experiment_template_name]
         if app_inst.repeats.repeat_index:
             suffix = f".{app_inst.repeats.repeat_index}"
             if experiment_template_name.endswith(suffix):
                 experiment_template_name = experiment_template_name[: -len(suffix)]
 
-        key = (
-            app_inst.variables[app_inst.keywords.application_name],
-            app_inst.variables[app_inst.keywords.workload_template_name],
-            experiment_template_name,
-        )
-        experiment_index_map[key].append(exp_name)
+        app_ns_raw = app_inst.variables[app_inst.keywords.application_namespace]
+        if app_ns_raw not in app_names_cache:
+            app_ns_spec = ramble.spec.Spec(app_ns_raw)
+            app_name = app_inst.variables[app_inst.keywords.application_name]
+            try:
+                repo_ns = (
+                    app_ns_spec.namespace
+                    or ramble.repository.paths[ramble.repository.ObjectTypes.applications]
+                    .repo_for_obj(app_name)
+                    .namespace
+                )
+            except Exception:
+                repo_ns = app_ns_spec.namespace
+
+            names = {app_name, app_ns_spec.fullname, f"app.{app_name}"}
+            if repo_ns:
+                names.add(f"{repo_ns}.{app_name}")
+                names.add(f"{repo_ns}.app.{app_name}")
+
+            app_names_cache[app_ns_raw] = tuple(names)
+
+        for a_name in app_names_cache[app_ns_raw]:
+            key = (
+                a_name,
+                app_inst.variables[app_inst.keywords.workload_template_name],
+                experiment_template_name,
+            )
+            experiment_index_map[key].append(exp_name)
 
     # Construct filters here...
     filters = ramble.filters.Filters(

lib/ramble/ramble/repository.py

@@ -205,6 +205,24 @@
 }
 
 
+@functools.lru_cache(maxsize=1)
+def get_object_type_map():
+    """Returns a mapping from string representations of object types (singular,
+    plural, abbrev, hyphens/underscores) to their corresponding ObjectType enum."""
+    mapping = {}
+    for obj_type, type_def in type_definitions.items():
+        candidates = set()
+        for key in ("abbrev", "dir_name", "singular"):
+            val = type_def.get(key)
+            if val:
+                val = val.replace(" ", "_")
+                candidates.update([val, val.replace("_", "-"), val.replace("-", "_")])
+
+        for cand in candidates:
+            mapping[cand] = obj_type
+    return mapping
+
+
 def _gen_path(repo_dirs=None, obj_type=default_type):
     """Create a RepoPath for a specific object, add it to sys.meta_path, and return it."""
     section_name = type_definitions[obj_type]["config_section"]
@@ -1223,12 +1241,12 @@ def filename_for_object_name(self, obj_name):
         obj_dir = self.dirname_for_object_name(obj_name)
         return os.path.join(obj_dir, self.object_file_name)
 
-    @autospec
     def object_path(self, spec):
+        spec_name = spec.name if isinstance(spec, ramble.spec.Spec) else spec
         return os.path.join(
             self.objects_path,
-            self.dirname_for_object_name(spec.name),
-            self.filename_for_object_name(spec.name),
+            self.dirname_for_object_name(spec_name),
+            self.filename_for_object_name(spec_name),
         )
 
     @property