Dart: Rebase generated imports from the SDK to the SDK base directory.

mojo/public/tools/bindings/generators/mojom_dart_generator.py

 # Copyright 2014 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Generates dart source files from a mojom.Module."""
 
+import os
 import re
 
 import mojom.generate.generator as generator
 import mojom.generate.module as mojom
 import mojom.generate.pack as pack
 from mojom.generate.template_expander import UseJinja
 
 GENERATOR_PREFIX = 'dart'
 
 _kind_to_dart_default_value = {
@@ skipping 349 matching lines @@
     'is_pointer_array_kind': IsPointerArrayKind,
     'is_struct_kind': mojom.IsStructKind,
     'dart_true_false': GetDartTrueFalse,
     'dart_type': DartDeclType,
     'name': GetNameForElement,
     'interface_response_name': GetInterfaceResponseName,
     'response_struct_from_method': generator.GetResponseStructFromMethod,
     'struct_from_method': generator.GetStructFromMethod,
   }
 
-  def GetParameters(self):
+  def GetParameters(self, args):
     return {
       "namespace": self.module.namespace,
-      "imports": self.GetImports(),
+      "imports": self.GetImports(args),
       "kinds": self.module.kinds,
       "enums": self.module.enums,
       "module": self.module,
       "structs": self.GetStructs() + self.GetStructsFromMethods(),
       "interfaces": self.module.interfaces,
       "imported_interfaces": self.GetImportedInterfaces(),
       "imported_from": self.ImportedFrom(),
     }
 
   @UseJinja("dart_templates/module.lib.tmpl", filters=dart_filters)
-  def GenerateLibModule(self):
-    return self.GetParameters()
+  def GenerateLibModule(self, args):
+    return self.GetParameters(args)
 
   def GenerateFiles(self, args):
-    self.Write(self.GenerateLibModule(),
+    self.Write(self.GenerateLibModule(args),
         self.MatchMojomFilePath("%s.dart" % self.module.name))
 
-  def GetImports(self):
+  def GetImports(self, args):
+    mojo_root_arg = next(
+        (x for x in args if x.startswith("--dart_mojo_root")), "")
+    (_, _, mojo_root_path) = mojo_root_arg.partition("=")

[tonyg, 2015/03/26 21:06:12]

Not sure, but should we be using argparse here or some other library? Seems like
--dart_mojo_root //foo/bar (with no =) should be just as legal as
--dart_mojo_root=//foo/bar.

[zra, 2015/03/26 23:33:20]

Anything that doesn't start with --dart is filtered from the list of strings
passed here, so a space instead of = means we won't see the path. I didn't want
to add --mojo_root as a top-level argument because it doesn't seem like any
other generator will need it, but if it turns out someone does, then we can pop
this out to the top-level script.

+    if not mojo_root_path.startswith("//"):
+      raise Exception("Malformed mojo SDK root: " + mojo_root_path)
+    mojo_root_path = mojo_root_path[2:]  # strip //
     used_names = set()
     for each_import in self.module.imports:
       simple_name = each_import["module_name"].split(".")[0]
 
       # Since each import is assigned a library in Dart, they need to have
       # unique names.
       unique_name = simple_name
       counter = 0
       while unique_name in used_names:
         counter += 1
         unique_name = simple_name + str(counter)
 
       used_names.add(unique_name)
       each_import["unique_name"] = unique_name + '_mojom'
       counter += 1
+
+      # At this point, a module's path is reletive to the root of the repo.
+      # However, imports of libraries from the Mojo SDK are always reletive to
+      # root of the Mojo SDK, which may be different from the root of the repo.
+      # This code uses the --dart_mojo_root argument to ensure that Mojo SDK
+      # imports are reletive to the Mojo SDK root.
+      path = each_import['module'].path
+      if os.path.commonprefix([mojo_root_path, path]) == mojo_root_path:
+        path = os.path.relpath(path, mojo_root_path)
+      each_import["rebased_path"] = path
     return self.module.imports
 
   def GetImportedInterfaces(self):
     interface_to_import = {}
     for each_import in self.module.imports:
       for each_interface in each_import["module"].interfaces:
         name = each_interface.name
         interface_to_import[name] = each_import["unique_name"] + "." + name
     return interface_to_import
 
   def ImportedFrom(self):
     interface_to_import = {}
     for each_import in self.module.imports:
       for each_interface in each_import["module"].interfaces:
         name = each_interface.name
         interface_to_import[name] = each_import["unique_name"] + "."
     return interface_to_import