| OLD | NEW |
| (Empty) |
| 1 // This code was auto-generated, is not intended to be edited, and is subject to | |
| 2 // significant change. Please see the README file for more information. | |
| 3 | |
| 4 library engine.source.io; | |
| 5 | |
| 6 import 'source.dart'; | |
| 7 import 'dart:io'; | |
| 8 import 'dart:uri'; | |
| 9 import 'java_core.dart'; | |
| 10 import 'java_io.dart'; | |
| 11 import 'package:analyzer-experimental/src/generated/sdk.dart' show DartSdk; | |
| 12 export 'source.dart'; | |
| 13 | |
| 14 /** | |
| 15 * Instances of the class {@code FileBasedSource} implement a source that repres
ents a file. | |
| 16 * @coverage dart.engine.source | |
| 17 */ | |
| 18 class FileBasedSource implements Source { | |
| 19 /** | |
| 20 * The source factory that created this source and that should be used to reso
lve URI's against | |
| 21 * this source. | |
| 22 */ | |
| 23 SourceFactory _factory; | |
| 24 /** | |
| 25 * The file represented by this source. | |
| 26 */ | |
| 27 JavaFile _file; | |
| 28 /** | |
| 29 * A flag indicating whether this source is in one of the system libraries. | |
| 30 */ | |
| 31 bool _inSystemLibrary = false; | |
| 32 /** | |
| 33 * Initialize a newly created source object. The source object is assumed to n
ot be in a system | |
| 34 * library. | |
| 35 * @param factory the source factory that created this source | |
| 36 * @param file the file represented by this source | |
| 37 */ | |
| 38 FileBasedSource.con1(SourceFactory factory, JavaFile file) { | |
| 39 _jtd_constructor_285_impl(factory, file); | |
| 40 } | |
| 41 _jtd_constructor_285_impl(SourceFactory factory, JavaFile file) { | |
| 42 _jtd_constructor_286_impl(factory, file, false); | |
| 43 } | |
| 44 /** | |
| 45 * Initialize a newly created source object. | |
| 46 * @param factory the source factory that created this source | |
| 47 * @param file the file represented by this source | |
| 48 * @param inSystemLibrary {@code true} if this source is in one of the system
libraries | |
| 49 */ | |
| 50 FileBasedSource.con2(SourceFactory factory2, JavaFile file3, bool inSystemLibr
ary2) { | |
| 51 _jtd_constructor_286_impl(factory2, file3, inSystemLibrary2); | |
| 52 } | |
| 53 _jtd_constructor_286_impl(SourceFactory factory2, JavaFile file3, bool inSyste
mLibrary2) { | |
| 54 this._factory = factory2; | |
| 55 this._file = file3; | |
| 56 this._inSystemLibrary = inSystemLibrary2; | |
| 57 } | |
| 58 bool operator ==(Object object) => object != null && identical(this.runtimeTyp
e, object.runtimeType) && _file == ((object as FileBasedSource))._file; | |
| 59 bool exists() => _file.exists(); | |
| 60 void getContents(Source_ContentReceiver receiver) { | |
| 61 { | |
| 62 String contents = _factory.getContents(this); | |
| 63 if (contents != null) { | |
| 64 receiver.accept2(contents); | |
| 65 return; | |
| 66 } | |
| 67 } | |
| 68 receiver.accept2(_file.readAsStringSync()); | |
| 69 } | |
| 70 String get encoding => _file.toURI().toString(); | |
| 71 String get fullName => _file.getAbsolutePath(); | |
| 72 int get modificationStamp { | |
| 73 int stamp = _factory.getModificationStamp(this); | |
| 74 if (stamp != null) { | |
| 75 return stamp; | |
| 76 } | |
| 77 return _file.lastModified(); | |
| 78 } | |
| 79 String get shortName => _file.getName(); | |
| 80 int get hashCode => _file.hashCode; | |
| 81 bool isInSystemLibrary() => _inSystemLibrary; | |
| 82 Source resolve(String uri) => _factory.resolveUri(this, uri); | |
| 83 Source resolveRelative(Uri containedUri) { | |
| 84 try { | |
| 85 Uri resolvedUri = file.toURI().resolveUri(containedUri); | |
| 86 return new FileBasedSource.con1(_factory, new JavaFile.fromUri(resolvedUri
)); | |
| 87 } on JavaException catch (exception) { | |
| 88 } | |
| 89 return null; | |
| 90 } | |
| 91 String toString() { | |
| 92 if (_file == null) { | |
| 93 return "<unknown source>"; | |
| 94 } | |
| 95 return _file.getAbsolutePath(); | |
| 96 } | |
| 97 /** | |
| 98 * Return the file represented by this source. This is an internal method that
is only intended to | |
| 99 * be used by {@link UriResolver}. | |
| 100 * @return the file represented by this source | |
| 101 */ | |
| 102 JavaFile get file => _file; | |
| 103 } | |
| 104 /** | |
| 105 * Instances of the class {@code DartUriResolver} resolve {@code dart} URI's. | |
| 106 * @coverage dart.engine.source | |
| 107 */ | |
| 108 class DartUriResolver extends UriResolver { | |
| 109 /** | |
| 110 * The Dart SDK against which URI's are to be resolved. | |
| 111 */ | |
| 112 DartSdk _sdk; | |
| 113 /** | |
| 114 * The name of the {@code dart} scheme. | |
| 115 */ | |
| 116 static String _DART_SCHEME = "dart"; | |
| 117 /** | |
| 118 * Return {@code true} if the given URI is a {@code dart:} URI. | |
| 119 * @param uri the URI being tested | |
| 120 * @return {@code true} if the given URI is a {@code dart:} URI | |
| 121 */ | |
| 122 static bool isDartUri(Uri uri) => uri.scheme == _DART_SCHEME; | |
| 123 /** | |
| 124 * Initialize a newly created resolver to resolve Dart URI's against the given
platform within the | |
| 125 * given Dart SDK. | |
| 126 * @param sdk the Dart SDK against which URI's are to be resolved | |
| 127 */ | |
| 128 DartUriResolver(DartSdk sdk) { | |
| 129 this._sdk = sdk; | |
| 130 } | |
| 131 Source resolveAbsolute(SourceFactory factory, Uri uri) { | |
| 132 if (!isDartUri(uri)) { | |
| 133 return null; | |
| 134 } | |
| 135 JavaFile resolvedFile = _sdk.mapDartUri(uri.toString()); | |
| 136 return new FileBasedSource.con2(factory, resolvedFile, true); | |
| 137 } | |
| 138 } | |
| 139 /** | |
| 140 * Instances of the class {@code PackageUriResolver} resolve {@code package} URI
's in the context of | |
| 141 * an application. | |
| 142 * @coverage dart.engine.source | |
| 143 */ | |
| 144 class PackageUriResolver extends UriResolver { | |
| 145 /** | |
| 146 * The package directories that {@code package} URI's are assumed to be relati
ve to. | |
| 147 */ | |
| 148 List<JavaFile> _packagesDirectories; | |
| 149 /** | |
| 150 * The name of the {@code package} scheme. | |
| 151 */ | |
| 152 static String _PACKAGE_SCHEME = "package"; | |
| 153 /** | |
| 154 * Return {@code true} if the given URI is a {@code package} URI. | |
| 155 * @param uri the URI being tested | |
| 156 * @return {@code true} if the given URI is a {@code package} URI | |
| 157 */ | |
| 158 static bool isPackageUri(Uri uri) => uri.scheme == _PACKAGE_SCHEME; | |
| 159 /** | |
| 160 * Initialize a newly created resolver to resolve {@code package} URI's relati
ve to the given | |
| 161 * package directories. | |
| 162 * @param packagesDirectories the package directories that {@code package} URI
's are assumed to be | |
| 163 * relative to | |
| 164 */ | |
| 165 PackageUriResolver(List<JavaFile> packagesDirectories) { | |
| 166 if (packagesDirectories.length < 1) { | |
| 167 throw new IllegalArgumentException("At least one package directory must be
provided"); | |
| 168 } | |
| 169 this._packagesDirectories = packagesDirectories; | |
| 170 } | |
| 171 Source resolveAbsolute(SourceFactory factory, Uri uri) { | |
| 172 if (!isPackageUri(uri)) { | |
| 173 return null; | |
| 174 } | |
| 175 String path4 = uri.path; | |
| 176 if (path4 == null) { | |
| 177 path4 = uri.path; | |
| 178 if (path4 == null) { | |
| 179 return null; | |
| 180 } | |
| 181 } | |
| 182 for (JavaFile packagesDirectory in _packagesDirectories) { | |
| 183 JavaFile resolvedFile = new JavaFile.relative(packagesDirectory, path4); | |
| 184 if (resolvedFile.exists()) { | |
| 185 return new FileBasedSource.con1(factory, resolvedFile); | |
| 186 } | |
| 187 } | |
| 188 return new FileBasedSource.con1(factory, new JavaFile.relative(_packagesDire
ctories[0], path4)); | |
| 189 } | |
| 190 } | |
| 191 /** | |
| 192 * Instances of the class {@link DirectoryBasedSourceContainer} represent a sour
ce container that | |
| 193 * contains all sources within a given directory. | |
| 194 * @coverage dart.engine.source | |
| 195 */ | |
| 196 class DirectoryBasedSourceContainer implements SourceContainer { | |
| 197 /** | |
| 198 * Append the system file separator to the given path unless the path already
ends with a | |
| 199 * separator. | |
| 200 * @param path the path to which the file separator is to be added | |
| 201 * @return a path that ends with the system file separator | |
| 202 */ | |
| 203 static String appendFileSeparator(String path) { | |
| 204 if (path == null || path.length <= 0 || path.codeUnitAt(path.length - 1) ==
JavaFile.separatorChar) { | |
| 205 return path; | |
| 206 } | |
| 207 return "${path}${JavaFile.separator}"; | |
| 208 } | |
| 209 /** | |
| 210 * The container's path (not {@code null}). | |
| 211 */ | |
| 212 String _path; | |
| 213 /** | |
| 214 * Construct a container representing the specified directory and containing a
ny sources whose{@link Source#getFullName()} starts with the directory's path. T
his is a convenience method, | |
| 215 * fully equivalent to {@link DirectoryBasedSourceContainer#DirectoryBasedSour
ceContainer(String)}. | |
| 216 * @param directory the directory (not {@code null}) | |
| 217 */ | |
| 218 DirectoryBasedSourceContainer.con1(JavaFile directory) { | |
| 219 _jtd_constructor_283_impl(directory); | |
| 220 } | |
| 221 _jtd_constructor_283_impl(JavaFile directory) { | |
| 222 _jtd_constructor_284_impl(directory.getPath()); | |
| 223 } | |
| 224 /** | |
| 225 * Construct a container representing the specified path and containing any so
urces whose{@link Source#getFullName()} starts with the specified path. | |
| 226 * @param path the path (not {@code null} and not empty) | |
| 227 */ | |
| 228 DirectoryBasedSourceContainer.con2(String path3) { | |
| 229 _jtd_constructor_284_impl(path3); | |
| 230 } | |
| 231 _jtd_constructor_284_impl(String path3) { | |
| 232 this._path = appendFileSeparator(path3); | |
| 233 } | |
| 234 bool contains(Source source) => source.fullName.startsWith(_path); | |
| 235 bool operator ==(Object obj) => (obj is DirectoryBasedSourceContainer) && ((ob
j as DirectoryBasedSourceContainer)).path == path; | |
| 236 /** | |
| 237 * Answer the receiver's path, used to determine if a source is contained in t
he receiver. | |
| 238 * @return the path (not {@code null}, not empty) | |
| 239 */ | |
| 240 String get path => _path; | |
| 241 int get hashCode => _path.hashCode; | |
| 242 } | |
| 243 /** | |
| 244 * Instances of the class {@code FileUriResolver} resolve {@code file} URI's. | |
| 245 * @coverage dart.engine.source | |
| 246 */ | |
| 247 class FileUriResolver extends UriResolver { | |
| 248 /** | |
| 249 * The name of the {@code file} scheme. | |
| 250 */ | |
| 251 static String _FILE_SCHEME = "file"; | |
| 252 /** | |
| 253 * Return {@code true} if the given URI is a {@code file} URI. | |
| 254 * @param uri the URI being tested | |
| 255 * @return {@code true} if the given URI is a {@code file} URI | |
| 256 */ | |
| 257 static bool isFileUri(Uri uri) => uri.scheme == _FILE_SCHEME; | |
| 258 /** | |
| 259 * Initialize a newly created resolver to resolve {@code file} URI's relative
to the given root | |
| 260 * directory. | |
| 261 */ | |
| 262 FileUriResolver() : super() { | |
| 263 } | |
| 264 Source resolveAbsolute(SourceFactory factory, Uri uri) { | |
| 265 if (!isFileUri(uri)) { | |
| 266 return null; | |
| 267 } | |
| 268 return new FileBasedSource.con1(factory, new JavaFile.fromUri(uri)); | |
| 269 } | |
| 270 } | |
| OLD | NEW |