add name field to add-pkg and add-dep

lib/wit/main.py

@@ -65,13 +65,15 @@ def main() -> None:
 
     add_pkg_parser = subparsers.add_parser('add-pkg', help='add a package to the workspace')
     add_pkg_parser.add_argument('repo', metavar='repo[::revision]', type=parse_dependency_tag)
+    add_pkg_parser.add_argument('name', nargs='?', default=None)
 
     update_pkg_parser = subparsers.add_parser('update-pkg', help='update the revision of a '
                                               'previously added package')
     update_pkg_parser.add_argument('repo', metavar='repo[::revision]', type=parse_dependency_tag)
 
     add_dep_parser = subparsers.add_parser('add-dep', help='add a dependency to a package')
     add_dep_parser.add_argument('pkg', metavar='pkg[::revision]', type=parse_dependency_tag)
+    add_dep_parser.add_argument('name', nargs='?', default=None)
 
     update_dep_parser = subparsers.add_parser('update-dep', help='update revision of a dependency '
                                               'in a package')
@@ -106,6 +108,9 @@ def main() -> None:
     elif args.prepend_repo_path:
         args.repo_path = args.prepend_repo_path
 
+    if 'name' not in args:
+        args.name = None
+
     if args.version:
         version()
         sys.exit(0)
@@ -181,7 +186,8 @@ def create(args) -> None:
         dependencies = args.add_pkg
 
     ws = WorkSpace.create(args.workspace_name, parse_repo_path(args))
-    for dep in dependencies:
+    for tag in dependencies:
+        dep = dependency_from_tag(ws.root, tag, None)
         ws.add_dependency(dep)
 
     if args.update:
@@ -193,31 +199,34 @@ def create(args) -> None:
 
 def add_pkg(ws, args) -> None:
     log.info("Adding package to workspace")
-    ws.add_dependency(args.repo)
+    dep = dependency_from_tag(ws.root, args.repo, args.name)
+    ws.add_dependency(dep)
 
 
 def update_pkg(ws, args) -> None:
-    ws.update_dependency(args.repo)
+    dep = dependency_from_tag(ws.root, args.repo, args.name)
+    ws.update_dependency(dep)
 
 
-def dependency_from_tag(wsroot, tag):
+def dependency_from_tag(wsroot, tag, name):
     source, revision = tag
 
     if (wsroot/source).exists() and (wsroot/source).parent == wsroot:
         repo = GitRepo((wsroot/source).name, wsroot)
+        name = name or (wsroot/source).name
         source = repo.get_remote()
     elif (wsroot/source).exists():
         source = str((wsroot/source).resolve())
     elif Path(source).exists():
         source = str(Path(source).resolve())
 
-    return Dependency(None, source, revision)
+    return Dependency(name, source, revision)
 
 
 def add_dep(ws, args) -> None:
     """ Resolve a Dependency then add it to the cwd's wit-manifest.json """
     packages = {pkg.name: pkg for pkg in ws.lock.packages}
-    req_dep = dependency_from_tag(ws.root, args.pkg)
+    req_dep = dependency_from_tag(ws.root, args.pkg, args.name)
 
     cwd = Path(os.getcwd()).resolve()
     cwd_dirname = cwd.relative_to(ws.root).parts[0]
@@ -254,7 +263,7 @@ def add_dep(ws, args) -> None:
 
 def update_dep(ws, args) -> None:
     packages = {pkg.name: pkg for pkg in ws.lock.packages}
-    req_dep = dependency_from_tag(ws.root, args.pkg)
+    req_dep = dependency_from_tag(ws.root, args.pkg, args.name)
 
     cwd = Path(os.getcwd()).resolve()
 

lib/wit/workspace.py

@@ -190,11 +190,8 @@ def checkout(self, packages):
         new_lock.write(new_lock_path)
         self.lock = new_lock
 
-    def add_dependency(self, tag) -> None:
+    def add_dependency(self, dep) -> None:
         """ Resolve a dependency then add it to the wit-workspace.json """
-        from .main import dependency_from_tag
-        dep = dependency_from_tag(self.root, tag)
-
         if self.manifest.contains_dependency(dep.name):
             error("Manifest already contains package {}".format(dep.name))
 
@@ -215,11 +212,7 @@ def add_dependency(self, tag) -> None:
 
         log.info("The workspace now depends on '{}'".format(dep.package.tag()))
 
-    def update_dependency(self, tag) -> None:
-        # init requested Dependency
-        from .main import dependency_from_tag
-        req_dep = dependency_from_tag(self.root, tag)
-
+    def update_dependency(self, req_dep) -> None:
         manifest_dep = self.manifest.get_dependency(req_dep.name)
 
         # check if the package is missing from the wit-workspace.json

t/wit_named_add.t

@@ -0,0 +1,56 @@
+#!/bin/sh
+
+. $(dirname $0)/regress_util.sh
+
+prereq on
+
+# Set up repo foo
+make_repo 'foo'
+foo_commit=$(git -C foo rev-parse HEAD)
+foo_dir=$PWD/foo
+
+make_repo 'bar'
+bar_commit=$(git -C bar rev-parse HEAD)
+bar_dir=$PWD/bar
+
+prereq off
+
+set -x
+# Now create an empty workspace
+wit init myws
+cd myws
+
+wit add-pkg $foo_dir
+check "wit add-pkg without name should succeed" [ $? -eq 0 ]
+
+wit add-pkg $foo_dir fizz
+check "wit add-pkg with name should succeed" [ $? -eq 0 ]
+
+wit update
+
+ls foo && ls fizz
+check "relevant packages should exist in workspace" [ $? -eq 0 ]
+
+cd fizz
+wit add-dep $bar_dir bazz
+check "wit add-dep with name should succeed" [ $? -eq 0 ]
+git add -A
+git commit -m "bump"
+cd ..
+
+wit update-pkg fizz
+wit update
+
+ls bazz
+check "relevant dependencies should exist in workspace" [ $? -eq 0 ]
+
+old_manifest=$(cat fizz/wit-manifest.json | md5)
+wit -C fizz add-dep $foo_dir bazz
+check "duplicate name should fail" [ $? -ne 0 ]
+new_manifest=$(cat fizz/wit-manifest.json | md5)
+check "manifest should not be changed" [ "$old_manifest" = "$new_manifest" ]
+
+set +x
+
+report
+finish