Merge "_CopyAndLinkFiles even if the sources haven't changed"
diff --git a/gitc_utils.py b/gitc_utils.py
index d082c8d..04307a3 100644
--- a/gitc_utils.py
+++ b/gitc_utils.py
@@ -15,6 +15,8 @@
 
 from __future__ import print_function
 import os
+import platform
+import re
 import sys
 import time
 
@@ -22,6 +24,7 @@
 import git_config
 import wrapper
 
+from manifest_xml import GitcManifest
 
 GITC_FS_ROOT_DIR = '/gitc/manifest-rw/'
 NUM_BATCH_RETRIEVE_REVISIONID = 300
@@ -65,26 +68,86 @@
       sys.exit(1)
     proj.revisionExpr = gitcmd.stdout.split('\t')[0]
 
-def generate_gitc_manifest(client_dir, manifest, projects=None):
+def _manifest_groups(manifest):
+  """Returns the manifest group string that should be synced
+
+  This is the same logic used by Command.GetProjects(), which is used during
+  repo sync
+
+  @param manifest: The XmlManifest object
+  """
+  mp = manifest.manifestProject
+  groups = mp.config.GetString('manifest.groups')
+  if not groups:
+    groups = 'default,platform-' + platform.system().lower()
+  return groups
+
+def generate_gitc_manifest(repodir, client_name, gitc_manifest, repo_manifest_file, paths=None):
   """Generate a manifest for shafsd to use for this GITC client.
 
-  @param client_dir: GITC client directory to install the .manifest file in.
-  @param manifest: XmlManifest object representing the repo manifest.
-  @param projects: List of projects we want to update, this must be a sublist
-                   of manifest.projects to work properly. If not provided,
-                   manifest.projects is used.
+  @param repodir: The repo directory
+  @param client_name: The gitc client name
+  @param gitc_manifest: Current gitc manifest, or None if there isn't one yet
+  @param repo_manifest_file: The file used by the main repo manifest
+  @param paths: List of project paths we want to update.
   """
+  manifest = GitcManifest(repodir, client_name)
+  manifest.Override(repo_manifest_file)
+
   print('Generating GITC Manifest by fetching revision SHAs for each '
         'project.')
-  if projects is None:
-    projects = manifest.projects
+  if paths is None:
+    paths = manifest.paths.keys()
+
+  groups = [x for x in re.split(r'[,\s]+', _manifest_groups(manifest)) if x]
+
+  # Convert the paths to projects, and filter them to the matched groups.
+  projects = [manifest.paths[p] for p in paths]
+  projects = [p for p in projects if p.MatchesGroups(groups)]
+
+  if gitc_manifest is not None:
+    for path, proj in manifest.paths.iteritems():
+      if not proj.MatchesGroups(groups):
+        continue
+
+      if not proj.upstream and not git_config.IsId(proj.revisionExpr):
+        proj.upstream = proj.revisionExpr
+
+      if not path in gitc_manifest.paths:
+        # Any new projects need their first revision, even if we weren't asked
+        # for them.
+        projects.append(proj)
+      elif not path in paths:
+        # And copy revisions from the previous manifest if we're not updating
+        # them now.
+        gitc_proj = gitc_manifest.paths[path]
+        if gitc_proj.old_revision:
+          proj.revisionExpr = None
+          proj.old_revision = gitc_proj.old_revision
+        else:
+          proj.revisionExpr = gitc_proj.revisionExpr
+
   index = 0
   while index < len(projects):
     _set_project_revisions(
         projects[index:(index+NUM_BATCH_RETRIEVE_REVISIONID)])
     index += NUM_BATCH_RETRIEVE_REVISIONID
+
+  if gitc_manifest is not None:
+    for path, proj in gitc_manifest.paths.iteritems():
+      if proj.old_revision and path in paths:
+        # If we updated a project that has been started, keep the old-revision
+        # updated.
+        repo_proj = manifest.paths[path]
+        repo_proj.old_revision = repo_proj.revisionExpr
+        repo_proj.revisionExpr = None
+
+  # Convert URLs from relative to absolute.
+  for name, remote in manifest.remotes.iteritems():
+    remote.fetchUrl = remote.resolvedFetchUrl
+
   # Save the manifest.
-  save_manifest(manifest, client_dir=client_dir)
+  save_manifest(manifest)
 
 def save_manifest(manifest, client_dir=None):
   """Save the manifest file in the client_dir.
@@ -95,7 +158,7 @@
   if not client_dir:
     client_dir = manifest.gitc_client_dir
   with open(os.path.join(client_dir, '.manifest'), 'w') as f:
-    manifest.Save(f)
+    manifest.Save(f, groups=_manifest_groups(manifest))
   # TODO(sbasi/jorg): Come up with a solution to remove the sleep below.
   # Give the GITC filesystem time to register the manifest changes.
-  time.sleep(3)
\ No newline at end of file
+  time.sleep(3)
diff --git a/manifest_xml.py b/manifest_xml.py
index a7fe8dd..3ac607e 100644
--- a/manifest_xml.py
+++ b/manifest_xml.py
@@ -167,12 +167,13 @@
   def _ParseGroups(self, groups):
     return [x for x in re.split(r'[,\s]+', groups) if x]
 
-  def Save(self, fd, peg_rev=False, peg_rev_upstream=True):
+  def Save(self, fd, peg_rev=False, peg_rev_upstream=True, groups=None):
     """Write the current manifest out to the given file descriptor.
     """
     mp = self.manifestProject
 
-    groups = mp.config.GetString('manifest.groups')
+    if groups is None:
+      groups = mp.config.GetString('manifest.groups')
     if groups:
       groups = self._ParseGroups(groups)
 
diff --git a/subcmds/gitc_init.py b/subcmds/gitc_init.py
index e99affa..c957a9d 100644
--- a/subcmds/gitc_init.py
+++ b/subcmds/gitc_init.py
@@ -68,15 +68,13 @@
       os.mkdir(self.client_dir)
     super(GitcInit, self).Execute(opt, args)
 
-    for name, remote in self.manifest.remotes.iteritems():
-      remote.fetchUrl = remote.resolvedFetchUrl
-
+    manifest_file = self.manifest.manifestFile
     if opt.manifest_file:
       if not os.path.exists(opt.manifest_file):
         print('fatal: Specified manifest file %s does not exist.' %
               opt.manifest_file)
         sys.exit(1)
-      self.manifest.Override(opt.manifest_file)
-    gitc_utils.generate_gitc_manifest(self.client_dir, self.manifest)
+      manifest_file = opt.manifest_file
+    gitc_utils.generate_gitc_manifest(self.repodir, opt.gitc_client, None, manifest_file)
     print('Please run `cd %s` to view your GITC client.' %
           os.path.join(gitc_utils.GITC_FS_ROOT_DIR, opt.gitc_client))
diff --git a/subcmds/start.py b/subcmds/start.py
index 188fd7c..940c341 100644
--- a/subcmds/start.py
+++ b/subcmds/start.py
@@ -57,7 +57,6 @@
         print("error: at least one project must be specified", file=sys.stderr)
         sys.exit(1)
 
-    proj_name_to_gitc_proj_dict = {}
     if self.gitc_manifest:
       all_projects = self.GetProjects(projects, manifest=self.gitc_manifest,
                                       missing_ok=True)
@@ -67,7 +66,6 @@
         else:
           project.already_synced = False
           project.old_revision = project.revisionExpr
-        proj_name_to_gitc_proj_dict[project.name] = project
         project.revisionExpr = None
       # Save the GITC manifest.
       gitc_utils.save_manifest(self.gitc_manifest)
@@ -77,9 +75,10 @@
     pm = Progress('Starting %s' % nb, len(all_projects))
     for project in all_projects:
       pm.update()
+
       if self.gitc_manifest:
-        gitc_project = proj_name_to_gitc_proj_dict[project.name]
-        # Sync projects that have already been opened.
+        gitc_project = self.gitc_manifest.paths[project.relpath]
+        # Sync projects that have not been opened.
         if not gitc_project.already_synced:
           proj_localdir = os.path.join(self.gitc_manifest.gitc_client_dir,
                                        project.relpath)
@@ -89,7 +88,7 @@
           project.Sync_NetworkHalf()
           sync_buf = SyncBuffer(self.manifest.manifestProject.config)
           project.Sync_LocalHalf(sync_buf)
-          project.revisionExpr = gitc_project.old_revision
+          project.revisionId = gitc_project.old_revision
 
       # If the current revision is a specific SHA1 then we can't push back
       # to it; so substitute with dest_branch if defined, or with manifest
@@ -100,6 +99,7 @@
           branch_merge = project.dest_branch
         else:
           branch_merge = self.manifest.default.revisionExpr
+
       if not project.StartBranch(nb, branch_merge=branch_merge):
         err.append(project)
     pm.end()
diff --git a/subcmds/sync.py b/subcmds/sync.py
index 7b44dbd..79cfaaa 100644
--- a/subcmds/sync.py
+++ b/subcmds/sync.py
@@ -670,32 +670,36 @@
       if opt.jobs is None:
         self.jobs = self.manifest.default.sync_j
 
-    # TODO (sbasi) - Add support for manifest changes, aka projects
-    # have been added or deleted from the manifest.
     if self.gitc_manifest:
       gitc_manifest_projects = self.GetProjects(args,
-                                                manifest=self.gitc_manifest,
                                                 missing_ok=True)
       gitc_projects = []
       opened_projects = []
       for project in gitc_manifest_projects:
-        if not project.old_revision:
-          gitc_projects.append(project)
+        if project.relpath in self.gitc_manifest.paths and \
+           self.gitc_manifest.paths[project.relpath].old_revision:
+          opened_projects.append(project.relpath)
         else:
-          opened_projects.append(project)
+          gitc_projects.append(project.relpath)
 
-      if gitc_projects and not opt.local_only:
+      if not args:
+        gitc_projects = None
+
+      if gitc_projects != [] and not opt.local_only:
         print('Updating GITC client: %s' % self.gitc_manifest.gitc_client_name)
-        gitc_utils.generate_gitc_manifest(self.gitc_manifest.gitc_client_dir,
+        gitc_utils.generate_gitc_manifest(self.repodir,
+                                          self.gitc_manifest.gitc_client_name,
                                           self.gitc_manifest,
+                                          self.manifest.manifestFile,
                                           gitc_projects)
         print('GITC client successfully synced.')
 
       # The opened projects need to be synced as normal, therefore we
       # generate a new args list to represent the opened projects.
-      args = []
-      for proj in opened_projects:
-        args.append(os.path.relpath(proj.worktree, os.getcwd()))
+      # TODO: make this more reliable -- if there's a project name/path overlap,
+      # this may choose the wrong project.
+      args = [os.path.relpath(self.manifest.paths[p].worktree, os.getcwd())
+              for p in opened_projects]
       if not args:
         return
     all_projects = self.GetProjects(args,