Parameterize uri resolution and parsing of options, use package:path

lib/file_generator.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of protoc;
 
 class FileGenerator extends ProtobufContainer {
   final FileDescriptorProto _fileDescriptor;
   final ProtobufContainer _parent;
   final GenerationContext _context;
@@ skipping 21 matching lines @@
   String get classname => '';
   String get fqname => '.${_fileDescriptor.package}';
 
   // Extract the filename from a URI and remove the extension.
   String _fileNameWithoutExtension(Uri filePath) {
     String fileName = filePath.pathSegments.last;
     int index = fileName.lastIndexOf(".");
     return index == -1 ? fileName : fileName.substring(0, index);
   }
 
-  // Create the URI for the generated Dart file from the URI of the
-  // .proto file.
-  Uri _generatedFilePath(Uri protoFilePath) {
-    var dartFileName = _fileNameWithoutExtension(protoFilePath) + ".pb.dart";
-    return protoFilePath.resolve(dartFileName);
-  }
-
   String _generateClassName(Uri protoFilePath) {
     String s = _fileNameWithoutExtension(protoFilePath).replaceAll('-', '_');
     return '${s[0].toUpperCase()}${s.substring(1)}';
   }
 
   String _generateLibraryName(Uri protoFilePath) {
     if (_fileDescriptor.package != '') return _fileDescriptor.package;
     return _fileNameWithoutExtension(protoFilePath).replaceAll('-', '_');
   }
 
-  Uri _relative(Uri target, Uri base) {
-    // Ignore the last segment of the base.
-    List<String> baseSegments =
-        base.pathSegments.sublist(0, base.pathSegments.length - 1);
-    List<String> targetSegments = target.pathSegments;
-    if (baseSegments.length == 1 && baseSegments[0] == '.') {
-      baseSegments = [];
-    }
-    if (targetSegments.length == 1 && targetSegments[0] == '.') {
-      targetSegments = [];
-    }
-    int common = 0;
-    int length = min(targetSegments.length, baseSegments.length);
-    while (common < length && targetSegments[common] == baseSegments[common]) {
-      common++;
-    }
-
-    final segments = <String>[];
-    if (common < baseSegments.length && baseSegments[common] == '..') {
-      throw new ArgumentError(
-          "Cannot create a relative path from $base to $target");
-    }
-    for (int i = common; i < baseSegments.length; i++) {
-      segments.add('..');
-    }
-    for (int i = common; i < targetSegments.length; i++) {
-      segments.add('${targetSegments[i]}');
-    }
-    if (segments.isEmpty) {
-      segments.add('.');
-    }
-    return new Uri(pathSegments: segments);
-  }
-
   CodeGeneratorResponse_File generateResponse() {
     MemoryWriter writer = new MemoryWriter();
     IndentingWriter out = new IndentingWriter('  ', writer);
 
     generate(out);
 
-    Uri filePath = new Uri(scheme: 'file', path: _fileDescriptor.name);
+    Uri filePath = new Uri.file(_fileDescriptor.name);
     return new CodeGeneratorResponse_File()
-        ..name = _generatedFilePath(filePath).path
+        ..name = _context.outputConfiguration.outputPathFor(filePath).path
         ..content = writer.toString();
   }
 
   void generate(IndentingWriter out) {
     Uri filePath = new Uri.file(_fileDescriptor.name);
     if (filePath.isAbsolute) {
         // protoc should never generate a file descriptor with an absolute path.
         throw("FAILURE: File with an absolute path is not supported");
     }
 
     String libraryName = _generateLibraryName(filePath);
 
     out.println(
       '///\n'
       '//  Generated code. Do not modify.\n'
       '///\n'
       'library $libraryName;\n'
       '\n'
       "import 'package:fixnum/fixnum.dart';\n"
       "import 'package:protobuf/protobuf.dart';"
     );
 
     for (String import in _fileDescriptor.dependency) {
       Uri importPath = new Uri.file(import);
       if (importPath.isAbsolute) {
         // protoc should never generate an import with an absolute path.
         throw("FAILURE: Import with absolute path is not supported");
       }
-      // Create a relative path from the current file to the import.
-      Uri relativeProtoPath = _relative(importPath, filePath);
+      // Create a path from the current file to the imported proto.
+      Uri resolvedImport = _context.outputConfiguration.resolveImport(
+          importPath, filePath);
       // Find the file generator for this import as it contains the
       // package name.
       FileGenerator fileGenerator = _context.lookupFile(import);
-      out.print("import '${_generatedFilePath(relativeProtoPath)}'");
+      out.print("import '$resolvedImport'");
       if (package != fileGenerator.package && !fileGenerator.package.isEmpty) {
         out.print(' as ${fileGenerator.packageImportPrefix}');
       }
       out.println(';');
     }
     out.println('');
 
     // Initialize Field.
     for (MessageGenerator m in messageGenerators) {
       m.initializeFields();
@@ skipping 22 matching lines @@
           out.println('  registry.add(${x.name});');
         }
         out.println('}');
       });
     }
   }
 }
 
 class GenerationContext {
   final GenerationOptions options;
+  final OutputConfiguration outputConfiguration;
   final Map<String, ProtobufContainer> _registry =
       <String, ProtobufContainer>{};
   final Map<String, FileGenerator> _files =
       <String, FileGenerator>{};
 
-  GenerationContext(this.options);
+  GenerationContext(this.options, this.outputConfiguration);
 
   void register(ProtobufContainer container) {
     _registry[container.fqname] = container;
     if (container is FileGenerator) {
       _files[container._fileDescriptor.name] = container;
     }
   }
 
   ProtobufContainer operator [](String fqname) => _registry[fqname];
 
   FileGenerator lookupFile(String name) => _files[name];
 }