368 lines
22 KiB
Dart
368 lines
22 KiB
Dart
import 'dart:io' show Platform;
|
||
|
||
import '../../l10n/tr.dart';
|
||
|
||
// 약속 (나누기 sync_tools): rsync 옵션 칸의 글 - 붙여 넣은 이상한 글자 고치기 · 인수로 나누기 · rsync 가 다르게 읽을 것 찾기 · 목록 파일 값.
|
||
// 입력: 옵션 글 (사용자가 적거나 붙여 넣은 것) · 낱말 목록 · Windows 인지 (null 이면 이 기기).
|
||
// 출력: 낱말 목록 · 문제 목록 ([OptionProblem]) · 고칠 방법 글. 오류: 던지지 않는다 (알아볼 수 없는 것은 문제 목록으로 돌려준다).
|
||
|
||
/// 관리자 지시 (10/20): 화면에서 줄바꿈 없이 묶은 옵션 글 (sync_preview_view 의 unbreakableOption) 의 줄바꿈 없는 빈칸 (U+00A0 등) ·
|
||
/// 보이지 않는 글자 (U+2060 등) 가 복사 · 붙여 넣기로 옵션에 들어오면 rsync 가 다른 인수로 읽는다 ("-", 보이지 않는 글자, "-filter") → 보통 빈칸으로 / 지움.
|
||
/// 다른 곳 (웹 페이지 · 문서) 에서 붙여 넣은 것도 같다
|
||
/// 28 확인 (10/20): 소프트 하이픈 (U+00AD) 은 지우고 (rsync 가 "unknown option" 으로 실패), 전각 빈칸 (U+3000) 도 보통 빈칸으로
|
||
String cleanOptionText(String s) => s
|
||
.replaceAll(RegExp('[\u00A0\u2007\u202F\u3000]'), ' ')
|
||
.replaceAll(RegExp('[\u00AD\u200B\u200C\u200D\u2060\uFEFF]'), '');
|
||
|
||
/// 낱말 맨 앞에서 - 로 읽는 대시 (‐ ‑ ‒ – — ― − ﹘ ﹣ －) - 워드 · 웹이 -- 를 바꿔 놓은 것
|
||
const _dashLike = '\u2010\u2011\u2012\u2013\u2014\u2015\u2212\uFE58\uFE63\uFF0D';
|
||
|
||
/// 굽은 따옴표 → 곧은 따옴표 (같은 무리끼리 열고 닫는다)
|
||
const _curlyQuote = {'\u2018': "'", '\u2019': "'", '\u201A': "'", '\u201C': '"', '\u201D': '"', '\u201E': '"'};
|
||
|
||
/// 옵션 글자를 인수로 나눈다 (큰따옴표 · 작은따옴표로 묶은 것은 하나로). 먼저 [cleanOptionText].
|
||
/// 관리자 지시 (10/20, 28 · 15 확인): 웹 · 문서에서 붙여 넣은 글을 곧은 글자로 쓴 것과 같게 읽는다 - 예전에는
|
||
/// --exclude=‘*.log’ 가 아무것도 거르지 못해 받는 쪽 keep.log 가 지워졌고, –delete 는 원본 경로로 넘어가 --delete 가 몰래 빠졌다.
|
||
/// - 굽은 따옴표 (‘ ’ “ ”) 는 낱말 맨 앞 · = 뒤 · 짧은 옵션 (-f) 뒤에서 열고, 같은 무리의 굽은 따옴표에서 닫는다
|
||
/// (곧은 따옴표처럼 뒤에 글이 이어져도 - “a b”.txt → a b.txt). 작은따옴표 무리는 글자 사이 (it’s) 이면 닫지 않는다.
|
||
/// 이름 안의 굽은 따옴표 (it’s.txt) 는 그대로 둔다.
|
||
/// - 닫히지 않은 따옴표 (15 확인 F1): 예전에는 뒤의 옵션을 모두 삼켜 지키려던 --exclude 가 사라졌다 → 그 따옴표를 글자로 보고
|
||
/// 나머지는 그대로 나누며, [unreadableOptions] 가 알려 실행을 막는다.
|
||
/// - 낱말 맨 앞의 대시 (– — ‑ － 등, 따옴표 밖): 둘이면 --, 하나면 rsync 의 긴 옵션 이름 (–delete) 일 때만 -- 그 밖 (–avz) 은 -.
|
||
/// 옵션의 값 자리 (--exclude –x.txt 의 –x.txt) · 낱말 가운데의 대시는 그대로 (파일 이름). --filter · -f 값의 규칙 머리 (“– *.tmp”) 는 - 로.
|
||
List<String> splitOptions(String s) => _parseOptions(s).words;
|
||
|
||
/// 짧은 옵션 묶음에서 값을 받는 rsync 글자 (popt): 그 글자 뒤의 글 (비었으면 다음 낱말) 이 값 - -avf"- *.log" · -rf "- x"
|
||
const rsyncShortWithArg = 'BefMT@';
|
||
|
||
/// = 없이 다음 낱말을 값으로 받는 rsync 긴 옵션 (--exclude x · --filter "- y")
|
||
const _rsyncLongWithArg = {
|
||
'address', 'backup-dir', 'block-size', 'bwlimit', 'checksum-choice', 'checksum-seed', 'chmod', 'chown', 'compare-dest',
|
||
'compress-choice', 'compress-level', 'contimeout', 'copy-as', 'copy-dest', 'debug', 'early-input', 'exclude', 'exclude-from',
|
||
'files-from', 'filter', 'groupmap', 'iconv', 'include', 'include-from', 'info', 'link-dest', 'log-file', 'log-file-format',
|
||
'max-alloc', 'max-delete', 'max-size', 'min-size', 'modify-window', 'only-write-batch', 'out-format', 'outbuf', 'partial-dir',
|
||
'password-file', 'port', 'protocol', 'read-batch', 'remote-option', 'rsh', 'rsync-path', 'skip-compress', 'sockopts',
|
||
'stop-after', 'stop-at', 'suffix', 'temp-dir', 'timeout', 'usermap', 'write-batch',
|
||
};
|
||
|
||
/// modular_sync #3 OptionText: 옵션 낱말들 ([splitOptions]) 에 rsync 옵션 [short] (한 글자, 짧은 묶음 안에서도) 또는 [long] (--이름) 이 있는지.
|
||
/// popt 처럼 읽는다 - 짧은 묶음은 한 글자씩, 값 자리 (값을 받는 글자 뒤 · 값을 받는 옵션의 다음 낱말) 는 옵션으로 보지 않는다.
|
||
/// 예전에는 "-로 시작하는 낱말에 그 글자가 있으면" 으로 봐서 -f'- build/' 의 u 를 -u 로 읽었다 (미리 보기 ≠ 실제)
|
||
bool rsyncHasOption(List<String> words, {String? short, String? long}) {
|
||
for (var i = 0; i < words.length; i++) {
|
||
final o = words[i];
|
||
if (o.startsWith('--')) {
|
||
final eq = o.indexOf('=');
|
||
final name = eq < 0 ? o : o.substring(0, eq);
|
||
if (long != null && name == long) return true;
|
||
if (eq < 0 && _rsyncLongWithArg.contains(name.substring(2))) i++;
|
||
continue;
|
||
}
|
||
if (o.length < 2 || !o.startsWith('-')) continue;
|
||
for (var j = 1; j < o.length; j++) {
|
||
final ch = o[j];
|
||
if (short != null && ch == short) return true;
|
||
if (rsyncShortWithArg.contains(ch)) {
|
||
if (j == o.length - 1) i++;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
/// rsync 3.x 의 긴 옵션 이름 (앱에 든 rsync 3.5.1 의 --help) - 대시 하나로 붙여 넣은 –delete 를 --delete 로 읽을지 정한다
|
||
const _rsyncLong = {
|
||
'acls', 'address', 'append', 'append-verify', 'archive', 'atimes', 'backup', 'backup-dir', 'block-size', 'blocking-io',
|
||
'bwlimit', 'cc', 'checksum', 'checksum-choice', 'checksum-seed', 'chmod', 'chown', 'compare-dest', 'compress',
|
||
'compress-choice', 'compress-level', 'compress-threads', 'confine-root', 'contimeout', 'copy-as', 'copy-dest',
|
||
'copy-devices', 'copy-dirlinks', 'copy-links', 'copy-unsafe-links', 'crtimes', 'cvs-exclude', 'daemon', 'debug', 'del',
|
||
'delay-updates', 'delete', 'delete-after', 'delete-before', 'delete-delay', 'delete-during', 'delete-excluded',
|
||
'delete-missing-args', 'devices', 'dirs', 'dry-run', 'early-input', 'exclude', 'exclude-from', 'executability', 'existing',
|
||
'fake-super', 'files-from', 'filter', 'force', 'from0', 'fsync', 'fuzzy', 'group', 'groupmap', 'hard-links', 'help',
|
||
'human-readable', 'i-r', 'iconv', 'ignore-errors', 'ignore-existing', 'ignore-missing-args', 'ignore-non-existing',
|
||
'ignore-times', 'inc-recursive', 'include', 'include-from', 'info', 'inplace', 'insecure-links', 'ipv4', 'ipv6',
|
||
'itemize-changes', 'keep-dirlinks', 'link-dest', 'links', 'list-only', 'log-file', 'log-file-format', 'max-alloc',
|
||
'max-delete', 'max-size', 'min-size', 'mkpath', 'modify-window', 'munge-links', 'no-i-r', 'no-implied-dirs',
|
||
'no-inc-recursive', 'no-motd', 'no-whole-file', 'numeric-ids', 'old-args', 'old-d', 'old-dirs', 'omit-dir-times',
|
||
'omit-link-times', 'one-file-system', 'only-write-batch', 'open-noatime', 'out-format', 'outbuf', 'owner', 'partial',
|
||
'partial-dir', 'password-file', 'perms', 'port', 'preallocate', 'progress', 'protocol', 'prune-empty-dirs', 'quiet',
|
||
'read-batch', 'recursive', 'relative', 'remote-option', 'remove-source-files', 'rsh', 'rsync-path', 'safe-links',
|
||
'secluded-args', 'size-only', 'skip-compress', 'sockopts', 'sparse', 'specials', 'stats', 'stderr', 'stop-after', 'stop-at',
|
||
'suffix', 'super', 'temp-dir', 'timeout', 'times', 'trust-sender', 'update', 'usermap', 'verbose', 'version',
|
||
'whole-file', 'write-batch', 'write-devices', 'xattrs', 'zc', 'zl', 'zt',
|
||
};
|
||
|
||
/// 나눈 낱말: 맨 앞이 따옴표 안이었는지 (그러면 맨 앞 대시를 옵션으로 고치지 않는다)
|
||
typedef _Word = ({String text, bool quoted});
|
||
|
||
/// [splitOptions] · [unreadableOptions] 의 몸통: 낱말들과 닫히지 않은 따옴표 (뒤 글 일부)
|
||
({List<String> words, List<String> unclosed}) _parseOptions(String s) {
|
||
final chars = cleanOptionText(s).split('');
|
||
final literal = <int>{}; // 닫히지 않아 글자로 보는 따옴표 자리
|
||
final unclosed = <String>[];
|
||
while (true) {
|
||
final (raw, open) = _splitRaw(chars, literal);
|
||
if (open == null) return (words: _normalizeWords(raw), unclosed: unclosed);
|
||
literal.add(open);
|
||
final rest = chars.sublist(open).join().trim();
|
||
unclosed.add(rest.length > 30 ? '${rest.substring(0, 30)}…' : rest);
|
||
}
|
||
}
|
||
|
||
/// 따옴표 · 빈칸으로 나눈다. 끝까지 닫히지 않은 따옴표가 있으면 그 자리 (두 번째 값)
|
||
(List<_Word>, int?) _splitRaw(List<String> chars, Set<int> literal) {
|
||
final out = <_Word>[];
|
||
final cur = StringBuffer();
|
||
String? quote; // 닫는 곧은 따옴표 (" 또는 ')
|
||
var curly = false; // 굽은 따옴표로 열었는지
|
||
var openAt = -1;
|
||
var has = false;
|
||
var quoted = false;
|
||
bool letter(int i) => i >= 0 && i < chars.length && RegExp(r'[\p{L}\p{N}]', unicode: true).hasMatch(chars[i]);
|
||
for (var i = 0; i < chars.length; i++) {
|
||
final ch = chars[i];
|
||
if (quote != null) {
|
||
// 작은따옴표 무리의 ’ 가 글자 사이면 (it’s) 닫지 않는다
|
||
final closes = ch == quote && !curly ||
|
||
curly && _curlyQuote[ch] == quote && !(quote == "'" && letter(i - 1) && letter(i + 1));
|
||
if (closes) {
|
||
quote = null;
|
||
curly = false;
|
||
} else {
|
||
cur.write(ch);
|
||
}
|
||
} else if (literal.contains(i)) {
|
||
cur.write(ch);
|
||
} else if (ch == '"' || ch == "'") {
|
||
if (cur.isEmpty && !has) quoted = true;
|
||
quote = ch;
|
||
openAt = i;
|
||
has = true;
|
||
} else if (_curlyQuote.containsKey(ch) && (cur.isEmpty || '$cur'.endsWith('=') || RegExp(r'^-[A-Za-z0-9]+$').hasMatch('$cur'))) {
|
||
if (cur.isEmpty && !has) quoted = true;
|
||
quote = _curlyQuote[ch];
|
||
curly = true;
|
||
openAt = i;
|
||
has = true;
|
||
} else if (ch.trim().isEmpty) {
|
||
if (cur.isNotEmpty || has) out.add((text: cur.toString(), quoted: quoted));
|
||
cur.clear();
|
||
has = false;
|
||
quoted = false;
|
||
} else {
|
||
cur.write(ch);
|
||
}
|
||
}
|
||
if (quote != null) return (out, openAt);
|
||
if (cur.isNotEmpty || has) out.add((text: cur.toString(), quoted: quoted));
|
||
return (out, null);
|
||
}
|
||
|
||
bool _dashAt(String t, int i) => i < t.length && (t[i] == '-' || _dashLike.contains(t[i]));
|
||
|
||
/// 거르기 규칙 머리 ("– *.tmp" · "＋ *.txt") 를 rsync 가 읽는 - · + 로
|
||
String _fixRuleHead(String v) {
|
||
if (v.isEmpty) return v;
|
||
if (_dashLike.contains(v[0])) return '-${v.substring(1)}';
|
||
if (v[0] == '\uFF0B') return '+${v.substring(1)}';
|
||
return v;
|
||
}
|
||
|
||
/// 낱말 맨 앞 대시 고치기 · 거르기 값의 규칙 머리 고치기 (값 자리는 그대로)
|
||
List<String> _normalizeWords(List<_Word> raw) {
|
||
final out = <String>[];
|
||
var value = ''; // 다음 낱말이 값: 'filter' (규칙 머리를 고침) · 'other' (그대로)
|
||
for (final w in raw) {
|
||
var t = w.text;
|
||
if (value.isNotEmpty) {
|
||
out.add(value == 'filter' ? _fixRuleHead(t) : t);
|
||
value = '';
|
||
continue;
|
||
}
|
||
// 28 확인 (10/20): 곧은 하이픈과 섞인 것 (-–delete) 도 맨 앞 둘 중 하나라도 대시면 같은 규칙으로
|
||
if (!w.quoted && t.isNotEmpty && (_dashLike.contains(t[0]) || t.length > 1 && t[0] == '-' && _dashLike.contains(t[1]))) {
|
||
final n = _dashAt(t, 1) ? 2 : 1;
|
||
final rest = t.substring(n);
|
||
final name = rest.split('=').first;
|
||
final long = n == 2 || _rsyncLong.contains(name) || (name.startsWith('no-') && _rsyncLong.contains(name.substring(3)));
|
||
t = '${long ? '--' : '-'}$rest';
|
||
}
|
||
if (t.startsWith('--filter=')) {
|
||
t = '--filter=${_fixRuleHead(t.substring(9))}';
|
||
} else if (t.length > 1 && t.startsWith('-') && !t.startsWith('--')) {
|
||
final k = t.indexOf(RegExp('[BefMT@]'), 1);
|
||
if (k > 0 && t[k] == 'f' && k < t.length - 1) t = '${t.substring(0, k + 1)}${_fixRuleHead(t.substring(k + 1))}';
|
||
}
|
||
out.add(t);
|
||
if (t.startsWith('--')) {
|
||
if (!t.contains('=') && _rsyncLongWithValue.contains(t)) value = t == '--filter' ? 'filter' : 'other';
|
||
} else if (t.length > 1 && t.startsWith('-')) {
|
||
final k = t.indexOf(RegExp('[BefMT@]'), 1);
|
||
if (k == t.length - 1) value = t[k] == 'f' ? 'filter' : 'other';
|
||
}
|
||
}
|
||
return out;
|
||
}
|
||
|
||
/// 값을 다음 낱말로 받는 rsync 긴 옵션 (--exclude *.log) - [unreadableOptions] 가 그 값을 옵션으로 보지 않게
|
||
const _rsyncLongWithValue = {
|
||
'--exclude', '--include', '--filter', '--exclude-from', '--include-from', '--files-from', '--backup-dir', '--suffix',
|
||
'--log-file', '--log-file-format', '--out-format', '--chmod', '--chown', '--usermap', '--groupmap', '--bwlimit',
|
||
'--timeout', '--contimeout', '--rsh', '--rsync-path', '--compare-dest', '--copy-dest', '--link-dest', '--partial-dir',
|
||
'--temp-dir', '--max-size', '--min-size', '--max-delete', '--modify-window', '--password-file', '--iconv',
|
||
'--block-size', '--checksum-choice', '--compress-choice', '--compress-level', '--skip-compress', '--info', '--debug',
|
||
'--sockopts', '--port', '--address', '--outbuf', '--remote-option', '--max-alloc', '--stop-after', '--stop-at',
|
||
'--write-batch', '--only-write-batch', '--read-batch', '--protocol', '--checksum-seed', '--copy-as', '--early-input',
|
||
// 28 확인 (10/20): rsync --help 의 짧은 별칭 (aka --cc · --zc · --zl · --zt) 과 값 받는 옵션 - 빠져 있어 값이 "경로로 읽힙니다" 로 막혔다
|
||
'--cc', '--zc', '--zl', '--zt', '--compress-threads', '--confine-root',
|
||
};
|
||
|
||
/// 관리자 지시 (10/20, 28 · 15 확인): [splitOptions] 로 고쳐 읽은 뒤에도 rsync 가 다르게 읽을 것 - 있으면 확인 창 · 실시간 동기화에
|
||
/// 빨갛게 알리고 실행을 막는다: 닫히지 않은 따옴표, 옵션 자리의 - 로 시작하지 않는 낱말 (rsync 는 원본 경로로 읽어 옵션이 몰래 빠짐),
|
||
/// 하이픈 셋 이상, 끝에 값 없이 남은 값 받는 옵션. 옵션의 값 자리 (--exclude 한글.txt 의 한글.txt, -f 뒤) 는 세지 않는다
|
||
List<String> unreadableOptions(String options, {bool? windows}) => [for (final x in optionProblems(options, windows: windows)) x.text];
|
||
|
||
/// 옵션 칸의 문제 종류 - 안내의 끝 문구 (고칠 방법) 를 고른다 (관리자 지시 10/20, 28 지적)
|
||
enum OptionProblemKind { unclosed, path, noValue, odd, doubleQuote, relativePath, stdin }
|
||
|
||
/// [unreadableOptions] 의 한 줄과 그 종류
|
||
class OptionProblem {
|
||
final OptionProblemKind kind;
|
||
final String text;
|
||
|
||
/// [text] 안의 옵션 낱말 (화면이 줄바꿈 없이 묶는다)
|
||
final String token;
|
||
const OptionProblem(this.kind, this.text, [this.token = '']);
|
||
|
||
@override
|
||
String toString() => text;
|
||
}
|
||
|
||
/// 문제 종류에 맞는 고칠 방법 (여러 종류면 · 로 잇는다)
|
||
String optionProblemHint(Iterable<OptionProblem> problems, {bool? windows}) {
|
||
windows ??= Platform.isWindows;
|
||
final kinds = {for (final x in problems) x.kind};
|
||
return [
|
||
if (kinds.contains(OptionProblemKind.unclosed)) tr('따옴표를 닫아 주세요'),
|
||
if (kinds.contains(OptionProblemKind.path)) tr('옵션은 - 나 -- 로 시작합니다'),
|
||
if (kinds.contains(OptionProblemKind.noValue)) tr('값을 적어 주세요 (예: --exclude=*.tmp)'),
|
||
if (kinds.contains(OptionProblemKind.odd)) tr('곧은 따옴표와 하이픈 (-) 으로 다시 적어 주세요'),
|
||
if (kinds.contains(OptionProblemKind.doubleQuote)) tr('큰따옴표 (") 를 빼 주세요'),
|
||
// 관리자 지시 (10/20): Windows 는 드라이브로 시작하는 전체 경로만 ("/" 는 rsync 가 자기 설치 폴더 기준으로 읽음), Android 는 /
|
||
if (kinds.contains(OptionProblemKind.relativePath)) windows ? tr('C:\\ 처럼 드라이브로 시작하는 전체 경로로') : tr('/ 로 시작하는 전체 경로로'),
|
||
if (kinds.contains(OptionProblemKind.stdin)) tr('목록 파일의 전체 경로를 적어 주세요'),
|
||
].join(' · ');
|
||
}
|
||
|
||
/// "옵션을 알아볼 수 없습니다: … - 고칠 방법" (작업 기록 · 실시간 동기화 카드 · 설정 칸)
|
||
String optionProblemMessage(List<OptionProblem> problems) =>
|
||
trf('옵션을 알아볼 수 없습니다: {0} - {1}', [problems.join(' · '), optionProblemHint(problems)]);
|
||
|
||
/// [unreadableOptions] 의 몸통 (종류와 함께)
|
||
List<OptionProblem> optionProblems(String options, {bool? windows}) {
|
||
windows ??= Platform.isWindows;
|
||
final parsed = _parseOptions(options);
|
||
// 15 확인 F1: 닫히지 않은 따옴표 - 뒤의 옵션이 다르게 읽힐 수 있다
|
||
final bad = [for (final u in parsed.unclosed) OptionProblem(OptionProblemKind.unclosed, trf('따옴표가 닫히지 않았습니다: {0}', [u]), u)];
|
||
var value = false;
|
||
var last = '';
|
||
for (final t in parsed.words) {
|
||
// P0 (10/20): Windows 의 rsync (MSYS2) 에는 큰따옴표가 든 인수를 그대로 넘길 수 없다 (prepareRsyncLaunch) - 값 자리도.
|
||
// 닫히지 않은 따옴표로 이미 막혔으면 (그 따옴표가 낱말에 남음) 한 번만 알린다
|
||
if (windows && parsed.unclosed.isEmpty && t.contains('"')) {
|
||
bad.add(OptionProblem(OptionProblemKind.doubleQuote, trf('큰따옴표 (") 가 든 옵션은 Windows 의 rsync 에 넘길 수 없습니다: {0}', [t]), t));
|
||
value = false;
|
||
continue;
|
||
}
|
||
if (value) {
|
||
value = false;
|
||
continue;
|
||
}
|
||
if (t.startsWith('---')) {
|
||
// 관리자 판단 (10/20, 28 확인): 하이픈이 셋 이상 (---delete) 은 rsync 가 알아보지 못한다 - 끝 문구는 "옵션은 - 나 -- 로 시작합니다"
|
||
bad.add(OptionProblem(OptionProblemKind.path, t, t));
|
||
} else if (t.startsWith('--')) {
|
||
value = !t.contains('=') && _rsyncLongWithValue.contains(t);
|
||
last = t;
|
||
} else if (t.length > 1 && t.startsWith('-')) {
|
||
// 짧은 옵션 묶음: 값을 받는 글자 (B · e · f · M · T · @) 가 끝이면 다음 낱말이 값 (rsync_filter 와 같은 규칙)
|
||
final k = t.indexOf(RegExp('[BefMT@]'), 1);
|
||
value = k == t.length - 1;
|
||
last = t;
|
||
} else {
|
||
// 관리자 판단 (10/20, 28 확인): 옵션 칸에는 경로가 들어갈 자리가 없다 (원본 · 대상은 앱이 넣음) - 값 자리가 아닌데
|
||
// - 로 시작하지 않는 낱말 (-a delete 의 delete, 혼자 쓴 -) 은 rsync 가 원본 경로로 읽어 옵션이 몰래 빠진다
|
||
// ASCII 밖 글자로 시작하면 (« … 등) 붙여 넣은 이상한 글자 - 안내는 곧은 글자로 다시 적기
|
||
bad.add(OptionProblem(t.codeUnitAt(0) > 0x7F ? OptionProblemKind.odd : OptionProblemKind.path, trf('경로로 읽힙니다: {0}', [t]), t));
|
||
}
|
||
}
|
||
// 값이 필요한 옵션이 끝에 값 없이 (--exclude) - rsync 가 원본 경로를 그 값으로 먹는다
|
||
if (value) bad.add(OptionProblem(OptionProblemKind.noValue, trf('{0} 의 값이 없습니다', [last]), last));
|
||
// 관리자 판단 (10/20): 목록 파일의 상대 경로 - rsync 는 자기 작업 폴더 (Windows 는 응답 파일 폴더) 기준으로, 미리 보기는 앱의
|
||
// 작업 폴더 기준으로 읽어 서로 다른 파일을 볼 수 있다. 전체 경로만 받는다
|
||
for (final f in listFileValues(parsed.words)) {
|
||
// 관리자 지시 (10/20, 28 지적): "-" (표준 입력) 는 따로 - 앱은 rsync 에 표준 입력을 주지 않는다
|
||
if (f == '-') {
|
||
bad.add(OptionProblem(OptionProblemKind.stdin, tr('표준 입력 (-) 은 쓸 수 없습니다'), f));
|
||
} else if (!_absolutePath(f, windows: windows)) {
|
||
bad.add(OptionProblem(OptionProblemKind.relativePath, trf('목록 파일은 전체 경로로 적어 주세요: {0}', [f]), f));
|
||
}
|
||
}
|
||
// 관리자 지시 (10/20, 28 확인): 기록 · 배치 파일도 - 상대 경로면 응답 파일 임시 폴더에 생겼다가 함께 지워져 찾을 수 없다.
|
||
// --backup-dir · --partial-dir · --temp-dir · --compare-dest 류는 받는 쪽 기준이라 그대로
|
||
for (final f in _optionValues(parsed.words, const {'--log-file', '--write-batch', '--read-batch', '--only-write-batch'})) {
|
||
if (!_absolutePath(f, windows: windows)) bad.add(OptionProblem(OptionProblemKind.relativePath, trf('기록 · 배치 파일은 전체 경로로 적어 주세요: {0}', [f]), f));
|
||
}
|
||
return bad;
|
||
}
|
||
|
||
/// 긴 옵션 [names] 의 값 (--이름=값 · --이름 값)
|
||
List<String> _optionValues(List<String> words, Set<String> names) => [
|
||
for (var i = 0; i < words.length; i++)
|
||
if (words[i].contains('=') && names.contains(words[i].substring(0, words[i].indexOf('='))))
|
||
words[i].substring(words[i].indexOf('=') + 1)
|
||
else if (names.contains(words[i]) && i + 1 < words.length)
|
||
words[i + 1],
|
||
];
|
||
|
||
/// 파일을 받는 옵션의 값 (--exclude-from · --include-from · --files-from · --filter / -f 의 ". 파일" · "merge 파일").
|
||
/// ": 이름" · dir-merge 는 폴더마다 읽는 파일 이름이라 (원래 상대) 빼고
|
||
List<String> listFileValues(List<String> words) {
|
||
const fileOpts = {'--exclude-from', '--include-from', '--files-from'};
|
||
final out = <String>[];
|
||
String? mergeFile(String rule) => RegExp(r'^(?:\.|merge)(?:,[^\s]*)?\s+(.+)$').firstMatch(rule.trim())?.group(1);
|
||
for (var i = 0; i < words.length; i++) {
|
||
final w = words[i];
|
||
final next = i + 1 < words.length ? words[i + 1] : null;
|
||
final eq = w.indexOf('=');
|
||
if (w.startsWith('--') && eq > 0 && fileOpts.contains(w.substring(0, eq))) {
|
||
out.add(w.substring(eq + 1));
|
||
} else if (fileOpts.contains(w) && next != null) {
|
||
out.add(next);
|
||
i++;
|
||
} else if (w.startsWith('--filter=')) {
|
||
final f = mergeFile(w.substring(9));
|
||
if (f != null) out.add(f);
|
||
} else if (w == '--filter' && next != null) {
|
||
final f = mergeFile(next);
|
||
if (f != null) out.add(f);
|
||
i++;
|
||
} else if (!w.startsWith('--') && w.length > 1 && w.startsWith('-')) {
|
||
// 짧은 옵션 묶음의 f: 붙은 값 (-f". 목록") 또는 다음 낱말 (-avf ". 목록")
|
||
final k = w.indexOf(RegExp('[BefMT@]'), 1);
|
||
if (k < 0 || w[k] != 'f') continue;
|
||
final rule = k == w.length - 1 ? next : w.substring(k + 1);
|
||
if (k == w.length - 1) i++;
|
||
final f = rule == null ? null : mergeFile(rule);
|
||
if (f != null) out.add(f);
|
||
}
|
||
}
|
||
return out;
|
||
}
|
||
|
||
/// 전체 경로. Windows: 드라이브 (C:\ · C:/) · UNC (\\서버 · //서버) · /cygdrive/… - 그 밖의 / 는 MSYS 가 자기 설치 폴더 기준으로 읽어 뺀다.
|
||
/// Android: / 로 시작
|
||
bool _absolutePath(String f, {required bool windows}) =>
|
||
windows ? RegExp(r'^(?:[A-Za-z]:[\\/]|\\\\|//|/cygdrive/)').hasMatch(f) : f.startsWith('/');
|