Skip to content

Commit d9a0e72

Browse files
tvolkerttvolkert
authored
Implement LocalFileSystem with new interface (flutter#8)
1 parent 18a00a3 commit d9a0e72

File tree

8 files changed

+277
-71
lines changed

8 files changed

+277
-71
lines changed

‎lib/local.dart‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1 @@
1+
export 'src/backends/local.dart';

‎lib/src/backends/local.dart‎

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,11 +1,13 @@
11
library file.src.backends.local;
22

33
import 'dart:async';
4+
import 'dart:convert';
45
import 'dart:io' as io;
56

6-
import 'package:file/src/interface.dart';
7+
import 'package:file/file.dart';
78

89
part 'local/local_directory.dart';
910
part 'local/local_file.dart';
1011
part 'local/local_file_system.dart';
1112
part 'local/local_file_system_entity.dart';
13+
part 'local/local_link.dart';

‎lib/src/backends/local/local_directory.dart‎

Lines changed: 45 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -1,32 +1,55 @@
11
part of file.src.backends.local;
22

3-
class _LocalDirectory extends _LocalFileSystemEntity implements Directory {
4-
_LocalDirectory(io.Directory entity, FileSystem system)
5-
: super(entity, system);
3+
class _LocalDirectory extends _LocalFileSystemEntity<
4+
_LocalDirectory,
5+
io.Directory> implements Directory {
6+
7+
_LocalDirectory(FileSystem fileSystem, io.Directory delegate)
8+
: super(fileSystem, delegate);
69

710
@override
8-
Future<Directory> copy(String newPath) async {
9-
throw new UnsupportedError('Not a supported operation');
10-
}
11+
_LocalDirectory _createNew(io.Directory delegate) =>
12+
new _LocalDirectory(fileSystem, delegate);
1113

1214
@override
13-
Future<Directory> create({bool recursive: false}) async {
14-
return new _LocalDirectory(
15-
await (_ioEntity as io.Directory).create(recursive: recursive),
16-
fileSystem);
17-
}
15+
Future<Directory> create({bool recursive: false}) async =>
16+
_createNew(await _delegate.create(recursive: recursive));
17+
18+
@override
19+
void createSync({bool recursive: false}) =>
20+
_delegate.createSync(recursive: recursive);
21+
22+
@override
23+
Future<Directory> createTemp([String prefix]) async =>
24+
_createNew(await _delegate.createTemp(prefix));
25+
26+
@override
27+
Directory createTempSync([String prefix]) =>
28+
_createNew(_delegate.createTempSync(prefix));
1829

1930
@override
20-
Stream<FileSystemEntity> list({bool recursive: false}) {
21-
io.Directory directory = _ioEntity;
22-
return directory.list(recursive: recursive).map((entity) {
23-
if (entity is io.File) {
24-
return new _LocalFile(entity, fileSystem);
25-
}
26-
if (entity is io.Directory) {
27-
return new _LocalDirectory(entity, fileSystem);
28-
}
29-
return null;
30-
}).where((e) => e != null);
31+
Stream<FileSystemEntity> list({
32+
bool recursive: false,
33+
bool followLinks: true,
34+
}) => _delegate.list(recursive: recursive, followLinks: followLinks)
35+
.map(_wrap);
36+
37+
@override
38+
List<FileSystemEntity> listSync({
39+
bool recursive: false,
40+
bool followLinks: true,
41+
}) => _delegate.listSync(recursive: recursive, followLinks: followLinks)
42+
.map((io.FileSystemEntity entity) => _wrap(entity))
43+
.toList();
44+
45+
FileSystemEntity _wrap(io.FileSystemEntity entity) {
46+
if (entity is io.File) {
47+
return new _LocalFile(fileSystem, entity);
48+
} else if (entity is io.Directory) {
49+
return new _LocalDirectory(fileSystem, entity);
50+
} else if (entity is io.Link) {
51+
return new _LocalLink(fileSystem, entity);
52+
}
53+
throw new io.FileSystemException('Unsupported type: $entity');
3154
}
3255
}

‎lib/src/backends/local/local_file.dart‎

Lines changed: 107 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -1,35 +1,122 @@
11
part of file.src.backends.local;
22

3-
class _LocalFile extends _LocalFileSystemEntity implements File {
4-
_LocalFile(io.File entity, FileSystem system) : super(entity, system);
3+
class _LocalFile extends _LocalFileSystemEntity<File, io.File> implements File {
4+
_LocalFile(FileSystem fileSystem, io.File delegate)
5+
: super(fileSystem, delegate);
56

67
@override
7-
Future<File> copy(String newPath) async {
8-
return new _LocalFile(
9-
await (_ioEntity as io.File).copy(newPath), fileSystem);
10-
}
8+
_LocalFile _createNew(io.File delegate) =>
9+
new _LocalFile(fileSystem, delegate);
1110

1211
@override
13-
Future<File> create({bool recursive: false}) async {
14-
return new _LocalFile(
15-
await (_ioEntity as io.File).create(recursive: recursive), fileSystem);
16-
}
12+
Future<File> create({bool recursive: false}) async =>
13+
_createNew(await _delegate.create(recursive: recursive));
1714

1815
@override
19-
Future<List<int>> readAsBytes() => (_ioEntity as io.File).readAsBytes();
16+
void createSync({bool recursive: false}) =>
17+
_delegate.createSync(recursive: recursive);
2018

2119
@override
22-
Future<String> readAsString() => (_ioEntity as io.File).readAsString();
20+
Future<File> copy(String newPath) async =>
21+
_createNew(await _delegate.copy(newPath));
2322

2423
@override
25-
Future<File> writeAsBytes(List<int> contents) async {
26-
return new _LocalFile(
27-
await (_ioEntity as io.File).writeAsBytes(contents), fileSystem);
28-
}
24+
File copySync(String newPath) => _createNew(_delegate.copySync(newPath));
2925

3026
@override
31-
Future<File> writeAsString(String contents) async {
32-
return new _LocalFile(
33-
await (_ioEntity as io.File).writeAsString(contents), fileSystem);
34-
}
27+
Future<int> length() => _delegate.length();
28+
29+
@override
30+
int lengthSync() => _delegate.lengthSync();
31+
32+
@override
33+
Future<DateTime> lastModified() => _delegate.lastModified();
34+
35+
@override
36+
DateTime lastModifiedSync() => _delegate.lastModifiedSync();
37+
38+
@override
39+
Future<io.RandomAccessFile> open({
40+
io.FileMode mode: io.FileMode.READ,
41+
}) async => _delegate.open(mode: mode);
42+
43+
@override
44+
io.RandomAccessFile openSync({io.FileMode mode: io.FileMode.READ}) =>
45+
_delegate.openSync(mode: mode);
46+
47+
@override
48+
Stream<List<int>> openRead([int start, int end]) =>
49+
_delegate.openRead(start, end);
50+
51+
@override
52+
io.IOSink openWrite({
53+
io.FileMode mode: io.FileMode.WRITE,
54+
Encoding encoding: UTF8,
55+
}) => _delegate.openWrite(mode: mode, encoding: encoding);
56+
57+
@override
58+
Future<List<int>> readAsBytes() => _delegate.readAsBytes();
59+
60+
@override
61+
List<int> readAsBytesSync() => _delegate.readAsBytesSync();
62+
63+
@override
64+
Future<String> readAsString({Encoding encoding: UTF8}) =>
65+
_delegate.readAsString(encoding: encoding);
66+
67+
@override
68+
String readAsStringSync({Encoding encoding: UTF8}) =>
69+
_delegate.readAsStringSync(encoding: encoding);
70+
71+
@override
72+
Future<List<String>> readAsLines({Encoding encoding: UTF8}) =>
73+
_delegate.readAsLines(encoding: encoding);
74+
75+
@override
76+
List<String> readAsLinesSync({Encoding encoding: UTF8}) =>
77+
_delegate.readAsLinesSync(encoding: encoding);
78+
79+
@override
80+
Future<File> writeAsBytes(
81+
List<int> bytes, {
82+
io.FileMode mode: io.FileMode.WRITE,
83+
bool flush: false,
84+
}) async => _createNew(await _delegate.writeAsBytes(
85+
bytes,
86+
mode: mode,
87+
flush: flush,
88+
));
89+
90+
@override
91+
void writeAsBytesSync(
92+
List<int> bytes, {
93+
io.FileMode mode: io.FileMode.WRITE,
94+
bool flush: false,
95+
}) => _delegate.writeAsBytesSync(bytes, mode: mode, flush: flush);
96+
97+
@override
98+
Future<File> writeAsString(
99+
String contents, {
100+
io.FileMode mode: io.FileMode.WRITE,
101+
Encoding encoding: UTF8,
102+
bool flush: false,
103+
}) async => _createNew(await _delegate.writeAsString(
104+
contents,
105+
mode: mode,
106+
encoding: encoding,
107+
flush: flush,
108+
));
109+
110+
@override
111+
void writeAsStringSync(
112+
String contents, {
113+
io.FileMode mode: io.FileMode.WRITE,
114+
Encoding encoding: UTF8,
115+
bool flush: false,
116+
}) => _delegate.writeAsStringSync(
117+
contents,
118+
mode: mode,
119+
encoding: encoding,
120+
flush: flush,
121+
);
35122
}

‎lib/src/backends/local/local_file_system.dart‎

Lines changed: 32 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -1,26 +1,44 @@
11
part of file.src.backends.local;
22

33
/// A wrapper implementation around `dart:io`'s implementation.
4-
class LocalFileSystem implements FileSystem {
4+
class LocalFileSystem extends FileSystem {
55
const LocalFileSystem();
66

77
@override
88
Directory directory(String path) =>
9-
new _LocalDirectory(new io.Directory(path), this);
9+
new _LocalDirectory(this, new io.Directory(path));
1010

1111
@override
12-
File file(String path) => new _LocalFile(new io.File(path), this);
12+
File file(String path) => new _LocalFile(this, new io.File(path));
1313

1414
@override
15-
Future<FileSystemEntityType> type(String path,
16-
{bool followLinks: true}) async {
17-
var type = await io.FileSystemEntity.type(path);
18-
if (type == io.FileSystemEntityType.FILE) {
19-
return FileSystemEntityType.FILE;
20-
} else if (type == io.FileSystemEntityType.DIRECTORY) {
21-
return FileSystemEntityType.DIRECTORY;
22-
} else {
23-
return FileSystemEntityType.NOT_FOUND;
24-
}
25-
}
15+
Directory get currentDirectory => directory(io.Directory.current.path);
16+
17+
@override
18+
set currentDirectory(dynamic path) => io.Directory.current = path;
19+
20+
@override
21+
Future<io.FileStat> stat(String path) => io.FileStat.stat(path);
22+
23+
@override
24+
io.FileStat statSync(String path) => io.FileStat.statSync(path);
25+
26+
@override
27+
Future<bool> identical(String path1, String path2) =>
28+
io.FileSystemEntity.identical(path1, path2);
29+
30+
@override
31+
bool identicalSync(String path1, String path2) =>
32+
io.FileSystemEntity.identicalSync(path1, path2);
33+
34+
@override
35+
bool get isWatchSupported => io.FileSystemEntity.isWatchSupported;
36+
37+
@override
38+
Future<io.FileSystemEntityType> type(String path, {bool followLinks: true}) =>
39+
io.FileSystemEntity.type(path, followLinks: followLinks);
40+
41+
@override
42+
io.FileSystemEntityType typeSync(String path, {bool followLinks: true}) =>
43+
io.FileSystemEntity.typeSync(path, followLinks: followLinks);
2644
}

‎lib/src/backends/local/local_file_system_entity.dart‎

Lines changed: 56 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -1,31 +1,73 @@
11
part of file.src.backends.local;
22

3-
abstract class _LocalFileSystemEntity implements FileSystemEntity {
3+
abstract class _LocalFileSystemEntity<
4+
T extends FileSystemEntity,
5+
D extends io.FileSystemEntity
6+
> implements FileSystemEntity {
7+
48
@override
59
final FileSystem fileSystem;
610

7-
io.FileSystemEntity _ioEntity;
11+
final D _delegate;
12+
13+
_LocalFileSystemEntity(this.fileSystem, this._delegate);
14+
15+
/// Creates a new entity with the same file system as this entity but backed
16+
/// by the specified delegate.
17+
T _createNew(D delegate);
18+
19+
@override
20+
Uri get uri => _delegate.uri;
21+
22+
@override
23+
Future<bool> exists() => _delegate.exists();
24+
25+
@override
26+
bool existsSync() => _delegate.existsSync();
27+
28+
@override
29+
Future<T> rename(String newPath) async =>
30+
_createNew(await _delegate.rename(newPath) as D);
31+
32+
@override
33+
T renameSync(String newPath) =>
34+
_createNew(_delegate.renameSync(newPath) as D);
35+
36+
@override
37+
Future<String> resolveSymbolicLinks() => _delegate.resolveSymbolicLinks();
38+
39+
@override
40+
String resolveSymbolicLinksSync() => _delegate.resolveSymbolicLinksSync();
41+
42+
@override
43+
Future<io.FileStat> stat() => _delegate.stat();
44+
45+
@override
46+
io.FileStat statSync() => _delegate.statSync();
847

9-
_LocalFileSystemEntity(this._ioEntity, this.fileSystem);
48+
@override
49+
Future<T> delete({bool recursive: false}) async =>
50+
_createNew(await _delegate.delete(recursive: recursive) as D);
51+
52+
@override
53+
void deleteSync({bool recursive: false}) =>
54+
_delegate.deleteSync(recursive: recursive);
1055

1156
@override
12-
Future<FileSystemEntity> delete({bool recursive: false}) async {
13-
await _ioEntity.delete(recursive: recursive);
14-
return this;
15-
}
57+
Stream<io.FileSystemEvent> watch({
58+
int events: io.FileSystemEvent.ALL,
59+
bool recursive: false,
60+
}) => _delegate.watch(events: events, recursive: recursive);
1661

1762
@override
18-
Future<bool> exists() => _ioEntity.exists();
63+
bool get isAbsolute => _delegate.isAbsolute;
1964

2065
@override
21-
Directory get parent => new _LocalDirectory(_ioEntity.parent, fileSystem);
66+
T get absolute => _createNew(_delegate.absolute as D);
2267

2368
@override
24-
String get path => _ioEntity.path;
69+
Directory get parent => new _LocalDirectory(fileSystem, _delegate.parent);
2570

2671
@override
27-
Future<FileSystemEntity> rename(String newPath) async {
28-
_ioEntity = await _ioEntity.rename(newPath);
29-
return this;
30-
}
72+
String get path => _delegate.path;
3173
}

0 commit comments

Comments
 (0)