@tyhld/conductor 0.12.137 → 0.12.138
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/package.json
CHANGED
package/scripts/hooks/README.md
CHANGED
|
@@ -641,9 +641,95 @@ TYHLD-platform の2便が、**読むだけの検索**で同じ `danger` に止
|
|
|
641
641
|
|
|
642
642
|
### 分かっている限界
|
|
643
643
|
|
|
644
|
-
-
|
|
645
|
-
|
|
646
|
-
|
|
644
|
+
- ~~**`$'…'` のような引用符で始まらない書き方で割れた探す言葉は、今までどおりパスとして測られます**~~
|
|
645
|
+
→ **1-12 で直しました**(「引用符で始まるか」ではなく「語の割り方が素朴分割へ倒れたか」で見る形に替えた)。
|
|
646
|
+
- **`-f` / `--file` と `-e` が混ざった形では、1つも外しません**(安全側に倒したまま)。
|
|
647
|
+
- **番人が古い機体では効きません。** 各PCで人が1回配布を流すまで、その機では今までどおりです。
|
|
648
|
+
|
|
649
|
+
## 1-12. ★割れたかどうかは「倒れたか」で見る・名指しを読み切る(便 362a7759/220a1e2c・2026-10-12)
|
|
650
|
+
|
|
651
|
+
### なぜ要るか(便 362a7759 の実地・読み違いで便が丸ごと止まった)
|
|
652
|
+
|
|
653
|
+
1-11 で直した形の**仲間が3つ残っていました**。`danger` の後は便の残りが止まるので(1-9)、
|
|
654
|
+
**読み違い1回で便が丸ごと止まります**。あわせて、**同じ1行から出ていた止め漏れ**も見つかりました。
|
|
655
|
+
|
|
656
|
+
| 形 | 何が起きたか | どの判定が読み違えたか |
|
|
657
|
+
| --- | --- | --- |
|
|
658
|
+
| **形A** | `$'…'` / `$"…"` / `x'…'` のように**引用符で始まらない書き方**で割れた探す言葉が、今までどおりパスとして測られ `danger` | `_pattern_word_positions`(最初の語が引用符そのもので始まるときだけ続きを外していた) |
|
|
659
|
+
| **形B** | `find <実在のファイル> -exec <読む道具> {} +` が**作業場所(リポの根)に倒れ**、根の秘密に当たって `danger` | `_find_feed_danger`(探す場所を**実在のフォルダだけ**で集めていた) |
|
|
660
|
+
| **形C** | 割れていない探す言葉(`-rn "'" <フォルダ>`)で**名指しのフォルダまで探す言葉として食い**、場所が無い扱いで `danger` | 形A と同じ1行 |
|
|
661
|
+
| **★穴H** | 同じ理由で**名指しの秘密のファイルまで探す言葉として読み飛ばし**、`-n "'" <秘密のファイル>` が**通っていた**(止め漏れ) | 形A と同じ1行 |
|
|
662
|
+
| **形D** | `--regexp=<語>` のように**値を `=` で繋げた旗**で探す言葉を渡すと、**名指しの探す場所を探す言葉と取り違え**、場所が0件になって「全体の再帰検索」に倒れ `discipline`(★探す言葉の中身とは無関係・普通の語でも止まっていた) | `_disc_search`(探す言葉を旗で明示する形を**空白で区切った書き方だけ**で見ていた) |
|
|
663
|
+
|
|
664
|
+
### どう直したか
|
|
665
|
+
|
|
666
|
+
- **形A・形C・穴H(1つの根っこ)** … 続きを外すかを「**引用符で始まるか**」ではなく
|
|
667
|
+
「**語の割り方が素朴分割へ倒れたか**」で見る形に替えました(新しい部品 `naive_token_split`。
|
|
668
|
+
`tokens_of` が倒れる条件と**同じ道具**で、割れたかどうかを決める所を1か所に寄せた)。
|
|
669
|
+
倒れたときだけ引用符が閉じるまでの語を続きとして外し、**倒れていなければ1つも外しません**
|
|
670
|
+
(引用符は剥がされているので、探す言葉は必ず1語で閉じている)。
|
|
671
|
+
★これで「引用符で始まらない書き方で続きを外せない(形A・形C)」と
|
|
672
|
+
「割れていないのに続きを外して名指しの秘密を読み飛ばす(穴H)」が**同時に**正しくなります。
|
|
673
|
+
- **形B** … `_find_feed_danger` が探す場所を集めるとき、**実在のファイル**も見るようにしました。
|
|
674
|
+
名指しの先が実在のファイルだけなら作業場所に倒さず、その段で名指しした**実在の秘密のファイル**は
|
|
675
|
+
今までどおり止めます(名指しの先そのものと、`-exec` の側に書いた名前の両方を見る)。
|
|
676
|
+
★1-10 が `_recursive_read_danger` で直した原因①と**同じ病気が find の判定に残っていた**形です。
|
|
677
|
+
- **形D** … `_disc_search` に、`--regexp=<語>` / `--file=<パス>` のように
|
|
678
|
+
**値を `=` で繋げた1語**も「探す言葉は旗で示されている」として読ませました(`_disc_pattern_joined`)。
|
|
679
|
+
★秘密の判定(`pattern_arg_positions`)は 1-11 から `--regexp=` を読めていたので、
|
|
680
|
+
食い違っていたのは**作法の判定の側だけ**でした。
|
|
681
|
+
|
|
682
|
+
### ★止める側は緩めていない(1件も減らない)
|
|
683
|
+
|
|
684
|
+
- 狭めるのは「探す文字」と「**実在が確かめられたファイル**」だけで、**名指しのパスは1つも外しません**
|
|
685
|
+
(`-f` / `--file` の値も今までどおりパス)。
|
|
686
|
+
- クォートが壊れた切れ端で外した分は、同じ命令を**本物の区切り**(引用符を守る割り方)で
|
|
687
|
+
必ず測り直します(`_real_segments`・便 2.5)。
|
|
688
|
+
- 形D の直しは**探す場所を正しく数える**だけなので、場所を書かない形・点1つ・リポの根は
|
|
689
|
+
今までどおり止まります(下の 止12〜止14)。
|
|
690
|
+
- **秘密として扱う名前の判定・読み書き持ち出しの動詞の一覧は1文字も変えていません。**
|
|
691
|
+
|
|
692
|
+
### 止める/通す(実測)
|
|
693
|
+
|
|
694
|
+
| # | 形 | 判定 | 理由 |
|
|
695
|
+
| --- | --- | --- | --- |
|
|
696
|
+
| 通1 | `<検索の道具> -n $'env: <語>\|home:' <名指しのファイル>`(形A) | **通す**(前は `danger`) | 倒れた切れ端の続きは探す言葉 |
|
|
697
|
+
| 通2 | 同じ形で `$"…"` / `x'…'` / 名指しのフォルダ・ファイル2つ・別の道具・`-e` の値・`--regexp=` の値 | **通す**(同) | 同 |
|
|
698
|
+
| 通3 | `<検索の道具> -rn "'" <名指しのフォルダ>`(形C) | **通す**(同) | 倒れていないので続きを外さない |
|
|
699
|
+
| 通4 | `find <実在のファイル> -exec <読む道具> {} +`(形B) | **通す**(同) | 名指しの先を読み切る |
|
|
700
|
+
| 通5 | 同じ形で ファイル2つ・`\| xargs`・検索の道具・`-execdir`・`-type f`・`-exec … \;` | **通す**(同) | 同 |
|
|
701
|
+
| 通6 | `<検索の道具> -rn --regexp=<語> <名指しのフォルダ>`(形D) | **通す**(前は `discipline`) | 繋げた旗でも探す場所を読み切る |
|
|
702
|
+
| 通7 | 同じ形で `--file=<普通のファイル>` / 別の道具 / ファイルを名指し | **通す**(同) | 同 |
|
|
703
|
+
| 止1 | 形Aの書き方+**秘密のファイルを名指し**(素・`-e`・`$"…"`) | **danger** | 本物の区切りの側で止まる |
|
|
704
|
+
| 止2 | 形Aの書き方で**作業場所の根**・点1つ・場所を書かない・実在しない場所・しるし(`*`)を含む場所 | **danger** | 作業場所として判定(前からの安全側) |
|
|
705
|
+
| 止3 | 形Aの書き方で**秘密を含むフォルダ**を名指し | **danger** | 探した場所の中に秘密が在る |
|
|
706
|
+
| 止4 | `-f` / `--file` の値が秘密のファイル(空白区切り・`=` で繋げた形の両方) | **danger** | 探す文字が書いてあるファイル=パス |
|
|
707
|
+
| 止5 | `find` で**秘密のファイルを名指し**・名前を並べて渡す・普通のファイルと混ぜる・`-exec` の側に書く | **danger** | 名指しの先が秘密 |
|
|
708
|
+
| 止6 | `find` で**秘密を含むフォルダ**・そのフォルダとファイルの混ぜ・作業場所の根・場所を書かない・実在しない場所 | **danger** | 前からの安全側 |
|
|
709
|
+
| 止7 | ★`<検索の道具> -n "'" <秘密のファイル>`(**穴H**・引用符1字/引用符で始まる語/`-e` の値/`--regexp=` の値/秘密と普通を並べる/別の道具) | **danger**(**前は通っていた**) | 名指しの秘密を探す言葉として読み飛ばさない |
|
|
710
|
+
| 止8 | `--regexp=<語>` +秘密のファイル・秘密を含むフォルダ・作業場所の根 | **danger** | 繋げた旗でも名指しはパス |
|
|
711
|
+
| 止9 | 記録の外まで読む旗つきで場所を書かない | **danger** | 前からの安全側(1-10) |
|
|
712
|
+
| 止10 | 秘密のファイルを読む(別の動詞)・秘密の環境変数の露出・変数を含む再帰の削除・フォルダごとの複製 | **danger** | ほかの判定(1文字も変えていない) |
|
|
713
|
+
| 止11 | この形と、同じ行の危険(秘密の読み・強い上書きの push・根を `find` ほか) | **danger** | ほかの判定が先に当たる |
|
|
714
|
+
| 止12 | `--regexp=<語>` / `--file=<パス>` で**探す場所を書かない**・点1つ | **discipline** | 全体の再帰検索(緩めていない) |
|
|
715
|
+
| 止13 | 旗なし・`-e` つきで探す場所を書かない・点1つ(前からの形) | **discipline** | 同 |
|
|
716
|
+
| 止14 | 別の道具の `--regexp=<語>` で探す場所を書かない | **discipline** | 同 |
|
|
717
|
+
|
|
718
|
+
直す前(`9b76b49`=0.12.137)と後を**104形**で突き合わせ、
|
|
719
|
+
**変わらない69**(止まり続ける `danger` 37 + 止まり続ける `discipline` 8 + 通り続ける 24。
|
|
720
|
+
うち**14形は判定が同じで理由の文だけが正確になった**=読み違いの語ではなく**本物の秘密の名前**を指すようになった)/
|
|
721
|
+
**★止まる→通る29**(形A 11・形B 8・形C 4・形D 6)/
|
|
722
|
+
**★通る→止まる6**(★**すべて穴H=止め漏れを塞いだ分**・いずれも名指しの秘密のファイルを読む形)/
|
|
723
|
+
**止まり方が変わった0**でした。
|
|
724
|
+
|
|
725
|
+
試験は `scripts/hooks/test_dollar_quote_and_find_file.py`(**116件**)。
|
|
726
|
+
空振り確認は、使い捨ての場所にリポの複製を作り `policy.py` を `9b76b49` に戻して流し、
|
|
727
|
+
**37件が落ちる**ことを確かめています(台本の中にも、判定の部品を旧い形へ差し替える空振りを10件入れてある)。
|
|
728
|
+
|
|
729
|
+
### 分かっている限界
|
|
730
|
+
|
|
731
|
+
- **`-e<語>` のように短い旗へ値を**くっつけた**書き方は、今までどおり読みません**
|
|
732
|
+
(`-e 語` と `--regexp=語` だけ。確かめられた形ではないので触っていません)。
|
|
647
733
|
- **`-f` / `--file` と `-e` が混ざった形では、1つも外しません**(安全側に倒したまま)。
|
|
648
734
|
- **番人が古い機体では効きません。** 各PCで人が1回配布を流すまで、その機では今までどおりです。
|
|
649
735
|
|
package/scripts/hooks/policy.py
CHANGED
|
@@ -662,6 +662,23 @@ def tokens_of(segment: str):
|
|
|
662
662
|
return segment.split()
|
|
663
663
|
|
|
664
664
|
|
|
665
|
+
def naive_token_split(segment) -> bool:
|
|
666
|
+
"""この区切りの語の割り方が【素朴分割へ倒れた】か(便 362a7759)。
|
|
667
|
+
|
|
668
|
+
★tokens_of と同じ判定を同じ道具で行う(=1か所で決める)。倒れたときだけ、
|
|
669
|
+
語に引用符が残る=1つの探す言葉が2語以上に割れていることがある。
|
|
670
|
+
倒れていないとき(shlex が通ったとき)は引用符が剥がされているので、
|
|
671
|
+
探す言葉は必ず1語で閉じている。
|
|
672
|
+
"""
|
|
673
|
+
if not segment:
|
|
674
|
+
return False
|
|
675
|
+
try:
|
|
676
|
+
shlex.split(segment, comments=False, posix=True)
|
|
677
|
+
except ValueError:
|
|
678
|
+
return True
|
|
679
|
+
return False
|
|
680
|
+
|
|
681
|
+
|
|
665
682
|
# 先頭に付く環境設定・ラッパ(実体の動詞まで読み進める)。
|
|
666
683
|
_WRAPPERS = frozenset({
|
|
667
684
|
'env', 'nohup', 'time', 'stdbuf', 'setsid', 'timeout', 'nice', 'ionice',
|
|
@@ -887,7 +904,7 @@ _PATTERN_FLAGS = ('-e', '--regexp')
|
|
|
887
904
|
_PATTERN_FILE_FLAGS = ('-f', '--file')
|
|
888
905
|
|
|
889
906
|
|
|
890
|
-
def _pattern_word_positions(args, first: int, word=None):
|
|
907
|
+
def _pattern_word_positions(args, first: int, word=None, naive: bool = False):
|
|
891
908
|
"""探す文字の語の位置を返す(引用符が壊れて空白で割られた続きも含める)。
|
|
892
909
|
|
|
893
910
|
★word を渡せば、引用符の開き具合をその字面で見る(`--regexp=<探す文字>` のように
|
|
@@ -903,21 +920,27 @@ def _pattern_word_positions(args, first: int, word=None):
|
|
|
903
920
|
パスとして測られ、`.env` で終わって見える語が秘密のファイルに当たって
|
|
904
921
|
読むだけの検索が danger で止まっていた(実地 便 3f54ac4a で便が丸ごと止まった)。
|
|
905
922
|
|
|
906
|
-
|
|
907
|
-
|
|
908
|
-
|
|
909
|
-
|
|
910
|
-
|
|
911
|
-
|
|
923
|
+
【どう使うか(便 362a7759 で「割れたか」の見分け方を根本から直した)】
|
|
924
|
+
語の割り方が【素朴分割へ倒れた】ときだけ、開いたままの引用符が閉じるまでの語を
|
|
925
|
+
同じ探す文字の続きとして外す(naive=True)。倒れていないとき(shlex が通ったとき)は
|
|
926
|
+
引用符が剥がされていて探す文字は必ず1語で閉じているので、続きを1つも外さない。
|
|
927
|
+
★見分けるのは「倒れたかどうか」であって「引用符で始まるかどうか」ではない。
|
|
928
|
+
便 18e9e32e は「最初の語が引用符そのもので始まる」を条件にしていたが、これは
|
|
929
|
+
① `$'…'` のように引用符で始まらない書き方(実測 この便の形A)では続きを外せず、
|
|
930
|
+
割れた2語目がパスとして測られて読むだけの検索が danger で止まり、
|
|
931
|
+
② 逆に、割れていないのに語の【途中】に引用符が1つ在る形(`-n "'" <秘密のファイル>`)では
|
|
932
|
+
続きを外してしまい、名指しの秘密のファイルまで探す文字として読み飛ばしていた
|
|
933
|
+
(実測 この便の重大発見2=止める側の穴)。
|
|
934
|
+
「倒れたかどうか」で見ると①②が同時に正しくなる(探す言葉の【途中】に引用符が1つ入る形
|
|
935
|
+
`-rn "it's" <フォルダ>` は shlex が通る=倒れていないので、今までどおり続きを外さない)。
|
|
912
936
|
★止める側は1件も減らない:クォートが壊れた切れ端は、同じ命令を本物の区切り
|
|
913
937
|
(split_commands・引用符を守る割り方)でも必ず測り直す(_real_segments・便 2.5)ので、
|
|
914
938
|
`<検索の道具> -n 'a\\|b' <秘密のファイル>` のような形は、そちらで今までどおり止まる。
|
|
915
|
-
★引用符が壊れていない(=語の割り方が正しい)ときは、最初の1語だけを外す
|
|
916
|
-
=これまでと同じ振る舞い。
|
|
917
939
|
"""
|
|
918
940
|
out = [first]
|
|
919
941
|
word = args[first] if word is None else word
|
|
920
|
-
if
|
|
942
|
+
if not naive:
|
|
943
|
+
# 語の割り方が正しかった=引用符は剥がされている。探す文字はこの1語で閉じている。
|
|
921
944
|
return out
|
|
922
945
|
quote = _open_quote(word)
|
|
923
946
|
i = first + 1
|
|
@@ -928,14 +951,18 @@ def _pattern_word_positions(args, first: int, word=None):
|
|
|
928
951
|
return out
|
|
929
952
|
|
|
930
953
|
|
|
931
|
-
def pattern_arg_positions(verb: str, args):
|
|
954
|
+
def pattern_arg_positions(verb: str, args, seg=None):
|
|
932
955
|
"""探す文字として扱う引数の位置を【全部】返す(無ければ空)。
|
|
933
956
|
|
|
934
957
|
★ここで返した位置だけをパスの判定から外す。それ以外は今までどおり全部測る。
|
|
935
958
|
★外すのは「探す文字」だけ:名指しのパス(-f / --file の値を含む)は1つも外さない。
|
|
959
|
+
★seg(測っている区切りの字面)を渡すと、語の割り方が素朴分割へ倒れたかを見て、
|
|
960
|
+
割れた探す言葉の続きも外す(便 362a7759)。渡さなければ続きを1つも外さない
|
|
961
|
+
=パスとして測る側が増える安全側。
|
|
936
962
|
"""
|
|
937
963
|
if verb not in _PATTERN_FIRST_VERBS:
|
|
938
964
|
return frozenset()
|
|
965
|
+
naive = naive_token_split(seg)
|
|
939
966
|
out = set()
|
|
940
967
|
explicit = False
|
|
941
968
|
i, n = 0, len(args)
|
|
@@ -948,20 +975,20 @@ def pattern_arg_positions(verb: str, args):
|
|
|
948
975
|
explicit = True
|
|
949
976
|
if i + 1 < n:
|
|
950
977
|
# `-e 語` の値は探す文字(パスではない)。値も引用符の壊れで割れることがある。
|
|
951
|
-
out.update(_pattern_word_positions(args, i + 1))
|
|
978
|
+
out.update(_pattern_word_positions(args, i + 1, naive=naive))
|
|
952
979
|
i += 2
|
|
953
980
|
continue
|
|
954
981
|
elif t.startswith('--regexp='):
|
|
955
982
|
explicit = True
|
|
956
983
|
# `--regexp=語` は旗に探す文字が埋まっている(開き具合は `=` の後ろだけで見る)。
|
|
957
|
-
out.update(_pattern_word_positions(args, i, t.split('=', 1)[1]))
|
|
984
|
+
out.update(_pattern_word_positions(args, i, t.split('=', 1)[1], naive=naive))
|
|
958
985
|
i += 1
|
|
959
986
|
if explicit:
|
|
960
987
|
return frozenset(out) # 探す文字は旗で示されている=最初の引数はパス
|
|
961
988
|
first = next((p for p, t in enumerate(args) if not t.startswith('-')), -1)
|
|
962
989
|
if first < 0:
|
|
963
990
|
return frozenset()
|
|
964
|
-
return frozenset(_pattern_word_positions(args, first))
|
|
991
|
+
return frozenset(_pattern_word_positions(args, first, naive=naive))
|
|
965
992
|
|
|
966
993
|
|
|
967
994
|
# 「中身を読み出す」動詞(秘密に対して使われたら露出)。
|
|
@@ -1628,7 +1655,7 @@ def _recursive_read_danger(verb: str, tokens, cwd=None, seg=None):
|
|
|
1628
1655
|
else:
|
|
1629
1656
|
return None
|
|
1630
1657
|
patterns = _search_excludes(args)
|
|
1631
|
-
skips = pattern_arg_positions(verb, args) # 探す文字は【全部】パスの判定から外す
|
|
1658
|
+
skips = pattern_arg_positions(verb, args, seg) # 探す文字は【全部】パスの判定から外す
|
|
1632
1659
|
roots = []
|
|
1633
1660
|
files = []
|
|
1634
1661
|
named = 0
|
|
@@ -1673,7 +1700,13 @@ def _recursive_read_danger(verb: str, tokens, cwd=None, seg=None):
|
|
|
1673
1700
|
|
|
1674
1701
|
|
|
1675
1702
|
def _find_feed_danger(command: str, cwd=None):
|
|
1676
|
-
"""`find <場所> -exec cat {}` や `find <場所> | xargs cat` の形で、場所の中に秘密が在れば理由を返す。
|
|
1703
|
+
"""`find <場所> -exec cat {}` や `find <場所> | xargs cat` の形で、場所の中に秘密が在れば理由を返す。
|
|
1704
|
+
|
|
1705
|
+
★名指しの先が【実在のファイル】だけなら、並べられるのはそのファイルだけなので
|
|
1706
|
+
作業場所に倒さない(便 362a7759・便 3be099ba の原因①と同じ考え方=
|
|
1707
|
+
実在が確かめられたときだけ狭める)。その代わり、その段で実在の秘密のファイルを
|
|
1708
|
+
名指ししていれば今までどおり止める(-exec の側に名前を書く形も見る)。
|
|
1709
|
+
"""
|
|
1677
1710
|
low = command
|
|
1678
1711
|
if not re.search(r'\bfind\b', low):
|
|
1679
1712
|
return None
|
|
@@ -1693,12 +1726,27 @@ def _find_feed_danger(command: str, cwd=None):
|
|
|
1693
1726
|
continue
|
|
1694
1727
|
args = toks[1:]
|
|
1695
1728
|
roots = []
|
|
1729
|
+
files = []
|
|
1696
1730
|
for a in args:
|
|
1697
1731
|
if a.startswith('-') or a in ('(', ')', '!'):
|
|
1698
1732
|
break
|
|
1699
1733
|
d = _existing_dir(a, cwd)
|
|
1700
1734
|
if d:
|
|
1701
1735
|
roots.append(d)
|
|
1736
|
+
continue
|
|
1737
|
+
f = _existing_file(a, cwd)
|
|
1738
|
+
if f:
|
|
1739
|
+
files.append(f)
|
|
1740
|
+
if not roots and files:
|
|
1741
|
+
# ★名指しの先が実在のファイルだけ=並べられるのはそのファイルだけなので倒さない。
|
|
1742
|
+
# その段で名指しした実在のファイルが秘密なら、今までどおり止める
|
|
1743
|
+
# (名指しの先そのものと、-exec の側に書いた名前の両方を見る)。
|
|
1744
|
+
for a in args:
|
|
1745
|
+
f = _existing_file(a, cwd)
|
|
1746
|
+
sr = secret_reason(f) if f else None
|
|
1747
|
+
if sr:
|
|
1748
|
+
return f'{sr} read through find'
|
|
1749
|
+
continue
|
|
1702
1750
|
if not roots:
|
|
1703
1751
|
base = cwd if (cwd and os.path.isabs(cwd)) else os.getcwd()
|
|
1704
1752
|
roots = [os.path.realpath(base)]
|
|
@@ -3513,7 +3561,7 @@ def _secret_danger(segment: str, verb: str, tokens, cwd=None):
|
|
|
3513
3561
|
args = tokens[1:] if tokens else []
|
|
3514
3562
|
# ★探す文字(grep の1つ目の引数・-e / --regexp の値・引用符が壊れて割れた続き)は
|
|
3515
3563
|
# パスではないので、パスの判定から外す(便 18e9e32e)。
|
|
3516
|
-
skips = pattern_arg_positions(verb, args)
|
|
3564
|
+
skips = pattern_arg_positions(verb, args, segment)
|
|
3517
3565
|
for pos, raw in enumerate(args):
|
|
3518
3566
|
if pos in skips:
|
|
3519
3567
|
continue
|
|
@@ -5200,6 +5248,16 @@ def _disc_is_whole(target, cwd):
|
|
|
5200
5248
|
return t in wide
|
|
5201
5249
|
|
|
5202
5250
|
|
|
5251
|
+
#: 探す文字(またはそれが書いてあるファイル)を旗で明示する書き方のうち、
|
|
5252
|
+
#: 値を `=` で繋げて1語にした形(`--regexp=語` / `--file=パス`)。
|
|
5253
|
+
#: ★これが在るときも「探す文字は旗で示されている」=旗でない引数はすべて【探す場所】。
|
|
5254
|
+
_DISC_PATTERN_JOINED = ('--regexp=', '--file=')
|
|
5255
|
+
|
|
5256
|
+
|
|
5257
|
+
def _disc_pattern_joined(w) -> bool:
|
|
5258
|
+
return any(w.startswith(p) for p in _DISC_PATTERN_JOINED)
|
|
5259
|
+
|
|
5260
|
+
|
|
5203
5261
|
def _disc_search(words, cwd):
|
|
5204
5262
|
if not words:
|
|
5205
5263
|
return None
|
|
@@ -5220,6 +5278,10 @@ def _disc_search(words, cwd):
|
|
|
5220
5278
|
if w in ('-e', '-f', '--regexp', '--file'):
|
|
5221
5279
|
has_e, skip = True, True
|
|
5222
5280
|
continue
|
|
5281
|
+
if _disc_pattern_joined(w):
|
|
5282
|
+
# `--regexp=語` / `--file=パス` … 探す文字は旗に埋まっている(便 220a1e2c)。
|
|
5283
|
+
has_e = True
|
|
5284
|
+
continue
|
|
5223
5285
|
if w.startswith('-'):
|
|
5224
5286
|
continue
|
|
5225
5287
|
pos.append(w)
|
|
@@ -5235,6 +5297,10 @@ def _disc_search(words, cwd):
|
|
|
5235
5297
|
if w in ('-e', '-f', '--regexp', '--file'):
|
|
5236
5298
|
has_e, skip = True, True
|
|
5237
5299
|
continue
|
|
5300
|
+
if _disc_pattern_joined(w):
|
|
5301
|
+
# `--regexp=語` / `--file=パス` … 探す文字は旗に埋まっている(便 220a1e2c)。
|
|
5302
|
+
has_e = True
|
|
5303
|
+
continue
|
|
5238
5304
|
if w in ('--max-depth', '-d', '--depth'):
|
|
5239
5305
|
depth, skip = 'next', True
|
|
5240
5306
|
continue
|
|
@@ -0,0 +1,475 @@
|
|
|
1
|
+
#!/usr/bin/env python3
|
|
2
|
+
"""引用符で始まらない探す言葉と、find で名指ししたファイルの検査(便 362a7759)。
|
|
3
|
+
|
|
4
|
+
実行: python3 scripts/hooks/test_dollar_quote_and_find_file.py
|
|
5
|
+
1件でも期待と違えば exit 1。
|
|
6
|
+
|
|
7
|
+
【なぜ要るか(便 18e9e32e の要判断2・3/便 3be099ba の要判断2 の持ち越し)】
|
|
8
|
+
読み違い1回で danger になり、0.12.133 から便が丸ごと止まる。便 18e9e32e が直した
|
|
9
|
+
「探す言葉を秘密のファイルと読み違える」形のほかに、同じ病気の形が残っていた。
|
|
10
|
+
|
|
11
|
+
形A … 引用符で始まらない書き方($'…' / x'…' / $"…")で割れた探す言葉が、
|
|
12
|
+
今までどおりパスとして測られる。
|
|
13
|
+
止める側の区切り(split_segments)は引用符の中でも機械的に割る(便 ad6b5db9・
|
|
14
|
+
正しい設計)ので、探す言葉に【空白】と【当て字の縦棒】の両方が入ると切れ端ができ、
|
|
15
|
+
クォートが壊れた切れ端では tokens_of が素朴分割へ倒れて探す言葉が2語以上に割れる。
|
|
16
|
+
便 18e9e32e の読み方は「最初の語が【引用符そのもので始まる】ときだけ続きを外す」
|
|
17
|
+
だったので、$'…' のように引用符で始まらない書き方では続きが外れず、
|
|
18
|
+
2語目(.env で終わって見える語)がパスとして測られて danger になっていた。
|
|
19
|
+
形B … find で【実在のファイル】を名指しして読む道具へ並べる形が、作業場所に倒れる。
|
|
20
|
+
探す場所を集める読み方が実在のフォルダだけを見ていたので、ファイルを名指しした形は
|
|
21
|
+
「場所を書いていない形」と同じに扱われ、作業場所(リポの根)の秘密に当たっていた
|
|
22
|
+
(便 3be099ba が _recursive_read_danger で直した原因①と同じ病気が、
|
|
23
|
+
find の判定(_find_feed_danger)に残っていた)。
|
|
24
|
+
形C … 形A と同じ1行から出ていた【止めすぎ】。割れていないのに続きを外していたので、
|
|
25
|
+
探す言葉が引用符で始まる形(`-rn "'" <フォルダ>`)で名指しのフォルダまで
|
|
26
|
+
探す言葉と見なし、場所が無い扱いになって作業場所に倒れていた。
|
|
27
|
+
穴H … 形A と同じ1行から出ていた【止め漏れ】。同じ理由で、名指しの【秘密のファイル】まで
|
|
28
|
+
探す言葉として読み飛ばしていた(`-n "'" <秘密のファイル>` が通っていた)。
|
|
29
|
+
★この便で塞ぐ(止める側が増える方向)。
|
|
30
|
+
形D … 探す文字を `=` で繋げた旗(`--regexp=語` / `--file=パス`)で渡した形が、
|
|
31
|
+
名指しの探す場所を探す文字と取り違えて止まる(便 220a1e2c で原因を確定)。
|
|
32
|
+
作法の判定(_disc_search)が、探す文字を旗で明示する形を【空白で区切った書き方】
|
|
33
|
+
(`-e 語` / `--regexp 語`)だけで見ていたため、`=` で繋げた1語は「ただの旗」として
|
|
34
|
+
読み飛ばされ、旗でない最初の引数(=名指しの探す場所)を探す文字として捨てていた。
|
|
35
|
+
名指しが1つだけだと探す場所が0件になり、「探す場所を書かない全体の再帰検索」に倒れて
|
|
36
|
+
discipline で止まっていた(★探す言葉の中身とは無関係で、普通の語でも止まっていた)。
|
|
37
|
+
★秘密の判定(pattern_arg_positions)は便 18e9e32e から `--regexp=` を読めていたので、
|
|
38
|
+
食い違っていたのは作法の判定の側だけ。
|
|
39
|
+
|
|
40
|
+
【どう直したか】割れたかどうかを「引用符で始まるか」ではなく
|
|
41
|
+
【語の割り方が素朴分割へ倒れたか】(naive_token_split)で見る。倒れたときだけ続きを外し、
|
|
42
|
+
倒れていないとき(shlex が通った=引用符が剥がされている)は1つも外さない。
|
|
43
|
+
find の側は、名指しの先が実在のファイルだけなら作業場所に倒さず、その段で名指しした
|
|
44
|
+
実在の秘密のファイルは今までどおり止める。
|
|
45
|
+
|
|
46
|
+
【ここで固定すること】
|
|
47
|
+
(a) 形A(引用符で始まらない書き方で割れた探す言葉)は通る
|
|
48
|
+
(b) 形B(find で名指しした普通のファイル)は通る
|
|
49
|
+
(c) 形C(割れていない探す言葉で名指しの場所を食わない)は通る
|
|
50
|
+
(d) 穴H(名指しの秘密のファイルを探す言葉として読み飛ばさない)は止まる
|
|
51
|
+
(i) 形D(`=` で繋げた旗でも名指しの場所を読み切る)は通る・作法と秘密の判定は緩まない
|
|
52
|
+
(e) 秘密の名指し・倒す判定は今までどおり止まる(1つも緩めない)
|
|
53
|
+
(f) ほかの危険の判定は、同じ行に混ざっていても今までどおり当たる
|
|
54
|
+
(g) 部品の単体(素朴分割へ倒れたかの見分け・語の広がり・実在のファイル)
|
|
55
|
+
(h) 空振り確認(直しを外すと、この台本が落ちる)
|
|
56
|
+
|
|
57
|
+
★秘密として扱う名前の判定・読み書き持ち出しの動詞の一覧は1文字も変えていない。
|
|
58
|
+
★この台本は検索の道具の名前と秘密の名前を素の字で置かない(組み立てて使う=既存の作法)。
|
|
59
|
+
"""
|
|
60
|
+
import os
|
|
61
|
+
import subprocess
|
|
62
|
+
import sys
|
|
63
|
+
import tempfile
|
|
64
|
+
|
|
65
|
+
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
|
|
66
|
+
|
|
67
|
+
import policy # noqa: E402
|
|
68
|
+
|
|
69
|
+
failures = []
|
|
70
|
+
|
|
71
|
+
|
|
72
|
+
def check(label, got, want):
|
|
73
|
+
ok = got == want
|
|
74
|
+
if not ok:
|
|
75
|
+
failures.append(f'{label}: got={got!r} want={want!r}')
|
|
76
|
+
print(f'{"OK " if ok else "NG "} {label:62} {str(got)[:40]}')
|
|
77
|
+
|
|
78
|
+
|
|
79
|
+
# ── 使い捨ての作り物(この台本のコードが作る=職人の命令の字面には出ない)────────
|
|
80
|
+
ROOT = tempfile.mkdtemp(prefix='dollar-quote-')
|
|
81
|
+
SITE = os.path.join(ROOT, 'site') # 作業場所(根に秘密の形の名前が在る)
|
|
82
|
+
os.makedirs(os.path.join(SITE, 'src'))
|
|
83
|
+
os.makedirs(os.path.join(SITE, 'clean', 'deep'))
|
|
84
|
+
os.makedirs(os.path.join(SITE, 'withsecret'))
|
|
85
|
+
ENV = '.env'
|
|
86
|
+
NPMRC = '.npm' + 'rc'
|
|
87
|
+
for _d in ('', 'withsecret'):
|
|
88
|
+
with open(os.path.join(SITE, _d, NPMRC), 'w') as f:
|
|
89
|
+
f.write('DUMMY=placeholder\n')
|
|
90
|
+
for _p in (('src', 'selfcheck.ts'), ('src', 'other.ts'), ('clean', 'deep', 'b.md')):
|
|
91
|
+
with open(os.path.join(SITE, *_p), 'w') as f:
|
|
92
|
+
f.write('needle\n')
|
|
93
|
+
_env = dict(os.environ, GIT_AUTHOR_NAME='p', GIT_AUTHOR_EMAIL='p@x',
|
|
94
|
+
GIT_COMMITTER_NAME='p', GIT_COMMITTER_EMAIL='p@x')
|
|
95
|
+
for _argv in (['git', 'init', '-q'], ['git', 'add', 'src'], ['git', 'commit', '-q', '-m', 'init']):
|
|
96
|
+
subprocess.run(_argv, cwd=SITE, env=_env, capture_output=True)
|
|
97
|
+
|
|
98
|
+
#: 秘密を1つも置かない作り物のリポ(作法の判定だけを見るための作業場所)。
|
|
99
|
+
#: ★秘密が在る作業場所では danger が先に当たるので、作法の判定(全体の再帰検索)が見えない。
|
|
100
|
+
PLAIN = os.path.join(ROOT, 'plain')
|
|
101
|
+
os.makedirs(os.path.join(PLAIN, 'src'))
|
|
102
|
+
with open(os.path.join(PLAIN, 'src', 'a.ts'), 'w') as f:
|
|
103
|
+
f.write('needle\n')
|
|
104
|
+
for _argv in (['git', 'init', '-q'], ['git', 'add', 'src'], ['git', 'commit', '-q', '-m', 'init']):
|
|
105
|
+
subprocess.run(_argv, cwd=PLAIN, env=_env, capture_output=True)
|
|
106
|
+
|
|
107
|
+
G = 'g' + 'rep'
|
|
108
|
+
RG = 'r' + 'g'
|
|
109
|
+
GG = 'git ' + 'grep'
|
|
110
|
+
FIND = 'f' + 'ind'
|
|
111
|
+
READ = 'c' + 'at'
|
|
112
|
+
#: 探す言葉に混ざる「.env で終わって見える語」(★パスではない・コードの書き方を調べる語)。
|
|
113
|
+
WORD = 'process' + ENV
|
|
114
|
+
#: 引用符で始まらない書き方の頭(ANSI-C の囲み)。
|
|
115
|
+
DQ = '$' + "'"
|
|
116
|
+
DD = '$' + '"'
|
|
117
|
+
Q = "'"
|
|
118
|
+
FILE1 = os.path.join(SITE, 'src', 'selfcheck.ts')
|
|
119
|
+
FILE2 = os.path.join(SITE, 'src', 'other.ts')
|
|
120
|
+
SECRET = os.path.join(SITE, NPMRC)
|
|
121
|
+
CLEAN = os.path.join(SITE, 'clean')
|
|
122
|
+
SRC = os.path.join(SITE, 'src')
|
|
123
|
+
WITHSECRET = os.path.join(SITE, 'withsecret')
|
|
124
|
+
PLAIN_SRC = os.path.join(PLAIN, 'src')
|
|
125
|
+
PATFILE = os.path.join(SITE, 'src', 'other.ts') # 探す文字が書いてあるファイル(普通)
|
|
126
|
+
|
|
127
|
+
|
|
128
|
+
def kind(cmd, cwd=SITE):
|
|
129
|
+
"""allow / gate / deny:<種類> を返す(deny は理由の頭で分ける)。"""
|
|
130
|
+
r = policy.decide_bash(cmd, cwd)
|
|
131
|
+
if r['decision'] != 'deny':
|
|
132
|
+
return r['decision']
|
|
133
|
+
return 'deny:' + (r['reason'] or '').split(':', 1)[0]
|
|
134
|
+
|
|
135
|
+
|
|
136
|
+
def reason(cmd, cwd=SITE):
|
|
137
|
+
return policy.decide_bash(cmd, cwd).get('reason') or ''
|
|
138
|
+
|
|
139
|
+
|
|
140
|
+
# ═════════════════════════════════════════════════════════════════════════════
|
|
141
|
+
# (a) 形A: 引用符で始まらない書き方で割れた探す言葉は、パスとして測らない
|
|
142
|
+
# ═════════════════════════════════════════════════════════════════════════════
|
|
143
|
+
print('── (a) 引用符で始まらない書き方で割れた探す言葉 ' + '─' * 20)
|
|
144
|
+
FORM_A = [
|
|
145
|
+
('a1 $\'…\' で実地と同じ語・名指しのファイル',
|
|
146
|
+
G + ' -n ' + DQ + 'env: ' + WORD + "\\|home:' " + FILE1),
|
|
147
|
+
('a2 $\'…\' で名指しのフォルダ(再帰の旗つき)',
|
|
148
|
+
G + ' -rn ' + DQ + 'env: ' + WORD + "\\|home:' " + SRC),
|
|
149
|
+
('a3 $\'…\' で名指しのフォルダ2つ',
|
|
150
|
+
G + ' -rn ' + DQ + 'x ' + WORD + "\\|y' " + SRC + ' ' + CLEAN),
|
|
151
|
+
('a4 $\'…\' で名指しのファイル2つ',
|
|
152
|
+
G + ' -n ' + DQ + 'x ' + WORD + "\\|y' " + FILE1 + ' ' + FILE2),
|
|
153
|
+
('a5 $\'…\' で別の道具(隠しも読む旗つき)',
|
|
154
|
+
RG + ' -n --hidden ' + DQ + 'x ' + WORD + "\\|y' " + SRC),
|
|
155
|
+
('a6 $\'…\' が -e の値',
|
|
156
|
+
G + ' -rn -e ' + DQ + 'x ' + WORD + "\\|y' " + SRC),
|
|
157
|
+
('a7 $\'…\' が --regexp= の値',
|
|
158
|
+
G + ' -rn --regexp=' + DQ + 'x ' + WORD + "\\|y' " + SRC),
|
|
159
|
+
('a8 引用符の前に字がある(x\'…\')',
|
|
160
|
+
G + " -rn x'y " + WORD + "\\|z' " + SRC),
|
|
161
|
+
('a9 $"…" の書き方',
|
|
162
|
+
G + ' -rn ' + DD + 'x ' + WORD + '\\|y" ' + SRC),
|
|
163
|
+
('a10 再帰の旗なし(名指しのファイル)',
|
|
164
|
+
G + ' -n ' + DQ + 'x ' + WORD + "\\|y' " + FILE2),
|
|
165
|
+
('a11 記録の外まで読む旗つき・名指しのフォルダ',
|
|
166
|
+
GG + ' --untracked -n ' + DQ + 'x ' + WORD + "\\|y' -- " + SRC),
|
|
167
|
+
('a12 当て字の縦棒2つ・語が真ん中',
|
|
168
|
+
G + ' -rn ' + DQ + 'a b\\|c ' + WORD + "\\|e' " + SRC),
|
|
169
|
+
('a13 $\'…\' のあとに縦棒で続ける(読むだけ)',
|
|
170
|
+
G + ' -n ' + DQ + 'x ' + WORD + "\\|y' " + FILE1 + ' | head -20'),
|
|
171
|
+
]
|
|
172
|
+
for label, cmd in FORM_A:
|
|
173
|
+
check(label, kind(cmd), 'allow')
|
|
174
|
+
|
|
175
|
+
# ═════════════════════════════════════════════════════════════════════════════
|
|
176
|
+
# (b) 形B: find で実在のファイルを名指しして読む道具へ並べる形は通る
|
|
177
|
+
# ═════════════════════════════════════════════════════════════════════════════
|
|
178
|
+
print('── (b) find で名指しした普通のファイル ' + '─' * 26)
|
|
179
|
+
FORM_B = [
|
|
180
|
+
('b1 ファイル1つを名指し+読む道具', FIND + ' ' + FILE1 + ' -exec ' + READ + ' {} +'),
|
|
181
|
+
('b2 ファイル2つを名指し',
|
|
182
|
+
FIND + ' ' + FILE1 + ' ' + FILE2 + ' -exec ' + READ + ' {} +'),
|
|
183
|
+
('b3 名前を並べて別の道具へ渡す', FIND + ' ' + FILE1 + ' | xargs ' + READ),
|
|
184
|
+
('b4 名指しのファイル+検索の道具', FIND + ' ' + FILE1 + ' -exec ' + G + ' -n x {} +'),
|
|
185
|
+
('b5 -execdir の形', FIND + ' ' + FILE1 + ' -execdir ' + READ + ' {} +'),
|
|
186
|
+
('b6 条件の旗つき', FIND + ' ' + FILE1 + ' -type f -exec ' + READ + ' {} +'),
|
|
187
|
+
('b7 名指しのファイル+持ち出しの道具', FIND + ' ' + FILE1 + ' -exec head -3 {} +'),
|
|
188
|
+
('b8 -exec を \\; で閉じる形', FIND + ' ' + FILE1 + ' -exec ' + READ + ' {} \\;'),
|
|
189
|
+
('b9 秘密を含まないフォルダとファイルの混ぜ',
|
|
190
|
+
FIND + ' ' + CLEAN + ' ' + FILE1 + ' -exec ' + READ + ' {} +'),
|
|
191
|
+
]
|
|
192
|
+
for label, cmd in FORM_B:
|
|
193
|
+
check(label, kind(cmd), 'allow')
|
|
194
|
+
|
|
195
|
+
# ═════════════════════════════════════════════════════════════════════════════
|
|
196
|
+
# (c) 形C: 割れていない探す言葉で、名指しの場所を探す言葉と見なさない
|
|
197
|
+
# ═════════════════════════════════════════════════════════════════════════════
|
|
198
|
+
print('── (c) 割れていない探す言葉は続きを食わない ' + '─' * 22)
|
|
199
|
+
FORM_C = [
|
|
200
|
+
('c1 探す言葉が引用符1字(名指しのフォルダ)', G + ' -rn "' + Q + '" ' + SRC),
|
|
201
|
+
('c2 引用符で始まる探す言葉(名指しのフォルダ2つ)',
|
|
202
|
+
G + ' -rn "' + Q + 'a" ' + SRC + ' ' + CLEAN),
|
|
203
|
+
('c3 引用符で始まる探す言葉(-e つき・名指しのフォルダ)',
|
|
204
|
+
G + ' -rn -e "' + Q + 'a" ' + SRC),
|
|
205
|
+
('c4 引用符で始まる探す言葉(--regexp= ・名指しのフォルダ)',
|
|
206
|
+
G + ' -rn --regexp="' + Q + 'a" ' + SRC),
|
|
207
|
+
('c5 探す言葉の途中に引用符が1つ(便 18e9e32e の形・名指しのフォルダ)',
|
|
208
|
+
G + ' -rn "it' + Q + 's" ' + SRC),
|
|
209
|
+
('c6 引用符で始まるが閉じている探す言葉', G + ' -rn "' + Q + 'needle' + Q + '" ' + SRC),
|
|
210
|
+
]
|
|
211
|
+
for label, cmd in FORM_C:
|
|
212
|
+
check(label, kind(cmd), 'allow')
|
|
213
|
+
|
|
214
|
+
# ═════════════════════════════════════════════════════════════════════════════
|
|
215
|
+
# (d) 穴H: 名指しの秘密のファイルを探す言葉として読み飛ばさない(★止める側が増える)
|
|
216
|
+
# ═════════════════════════════════════════════════════════════════════════════
|
|
217
|
+
print('── (d) 名指しの秘密を探す言葉として読み飛ばさない ' + '─' * 16)
|
|
218
|
+
HOLE = [
|
|
219
|
+
('d1 探す言葉が引用符1字+秘密のファイル', G + ' -n "' + Q + '" ' + SECRET),
|
|
220
|
+
('d2 引用符で始まる探す言葉+秘密のファイル', G + ' -n "' + Q + 'a" ' + SECRET),
|
|
221
|
+
('d3 秘密のファイルとふつうのファイルを並べる',
|
|
222
|
+
G + ' -n "' + Q + 'a" ' + SECRET + ' ' + FILE2),
|
|
223
|
+
('d4 -e の値が引用符で始まる+秘密のファイル', G + ' -n -e "' + Q + 'a" ' + SECRET),
|
|
224
|
+
('d5 --regexp= の値が引用符で始まる+秘密のファイル',
|
|
225
|
+
G + ' -n --regexp="' + Q + 'a" ' + SECRET),
|
|
226
|
+
('d6 探す言葉が引用符1字+別の道具で秘密のファイル', RG + ' -n "' + Q + '" ' + SECRET),
|
|
227
|
+
]
|
|
228
|
+
for label, cmd in HOLE:
|
|
229
|
+
check(label, kind(cmd), 'deny:danger')
|
|
230
|
+
check('d7 理由は本物の秘密の名前を指す', NPMRC in reason(G + ' -n "' + Q + '" ' + SECRET), True)
|
|
231
|
+
|
|
232
|
+
# ═════════════════════════════════════════════════════════════════════════════
|
|
233
|
+
# (i) 形D: 探す文字を `=` で繋げた旗(--regexp=語 / --file=パス)でも、
|
|
234
|
+
# 名指しの場所を探す文字と取り違えない
|
|
235
|
+
#
|
|
236
|
+
# 【原因(便 220a1e2c で確定)】作法の判定(_disc_search)は、探す文字を旗で明示する形を
|
|
237
|
+
# 【空白で区切った書き方】(`-e 語` / `--regexp 語`)だけで見ていた。`--regexp=語` のように
|
|
238
|
+
# 値を `=` で繋げた1語は「ただの旗」として読み飛ばされ、探す文字が示されていない扱いになり、
|
|
239
|
+
# 旗でない最初の引数(=名指しの探す場所)を探す文字として捨てていた。
|
|
240
|
+
# 名指しが1つだけなら探す場所が0件になり、「探す場所を書かない全体の再帰検索」に倒れて
|
|
241
|
+
# discipline で止まっていた(★探す言葉の中身とは関係なく、普通の語でも止まっていた)。
|
|
242
|
+
# ★秘密の判定(pattern_arg_positions)は便 18e9e32e から `--regexp=` を読めていたので、
|
|
243
|
+
# 食い違っていたのは作法の判定の側だけだった。
|
|
244
|
+
# ═════════════════════════════════════════════════════════════════════════════
|
|
245
|
+
print('── (i) 探す文字を = で繋げた旗でも名指しの場所を読み切る ' + '─' * 10)
|
|
246
|
+
FORM_D = [
|
|
247
|
+
('i1 --regexp= +名指しのフォルダ', G + ' -rn --regexp=needle ' + SRC),
|
|
248
|
+
('i2 --regexp= +名指しのフォルダ2つ', G + ' -rn --regexp=needle ' + SRC + ' ' + CLEAN),
|
|
249
|
+
('i3 --regexp= +名指しのファイル', G + ' -rn --regexp=needle ' + FILE1),
|
|
250
|
+
('i4 --file= +名指しのフォルダ', G + ' -rn --file=' + PATFILE + ' ' + SRC),
|
|
251
|
+
('i5 別の道具の --regexp= +名指しのフォルダ', RG + ' -n --regexp=needle ' + SRC),
|
|
252
|
+
('i6 egrep の --regexp= +名指しのフォルダ', 'eg' + 'rep -rn --regexp=needle ' + SRC),
|
|
253
|
+
('i7 --regexp= +秘密を含まない深いフォルダ',
|
|
254
|
+
G + ' -rn --regexp=needle ' + os.path.join(CLEAN, 'deep')),
|
|
255
|
+
]
|
|
256
|
+
for label, cmd in FORM_D:
|
|
257
|
+
check(label, kind(cmd), 'allow')
|
|
258
|
+
|
|
259
|
+
#: ★作法の判定は1つも緩めない(秘密を置かない作り物の根で測る=danger に隠れないため)。
|
|
260
|
+
DISC_KEEP = [
|
|
261
|
+
('i8 --regexp= で探す場所を書かない', G + ' -rn --regexp=needle'),
|
|
262
|
+
('i9 --regexp= で点1つ', G + ' -rn --regexp=needle .'),
|
|
263
|
+
('i10 --file= で探す場所を書かない', G + ' -rn --file=' + PLAIN_SRC + '/a.ts'),
|
|
264
|
+
('i11 別の道具の --regexp= で探す場所を書かない', RG + ' -n --regexp=needle'),
|
|
265
|
+
('i12 旗なしで探す場所を書かない(前からの形)', G + ' -rn needle'),
|
|
266
|
+
('i13 旗なしで点1つ(前からの形)', G + ' -rn needle .'),
|
|
267
|
+
('i14 -e で探す場所を書かない(前からの形)', G + ' -rn -e needle'),
|
|
268
|
+
]
|
|
269
|
+
for label, cmd in DISC_KEEP:
|
|
270
|
+
check(label, kind(cmd, PLAIN), 'deny:discipline')
|
|
271
|
+
check('i15 名指しのフォルダなら作法の判定は当たらない(前からの形)',
|
|
272
|
+
kind(G + ' -rn needle ' + PLAIN_SRC, PLAIN), 'allow')
|
|
273
|
+
|
|
274
|
+
#: ★秘密の判定は1つも緩めない(繋げた書き方でも名指しの秘密は止まる)。
|
|
275
|
+
DANGER_KEEP = [
|
|
276
|
+
('i16 --regexp= +秘密のファイルを名指し', G + ' -rn --regexp=needle ' + SECRET),
|
|
277
|
+
('i17 --regexp= +秘密を含むフォルダ', G + ' -rn --regexp=needle ' + WITHSECRET),
|
|
278
|
+
('i18 --regexp= +作業場所の根', G + ' -rn --regexp=needle ' + SITE),
|
|
279
|
+
('i19 --regexp= +探す場所を書かない(秘密が在る作業場所)', G + ' -rn --regexp=needle'),
|
|
280
|
+
('i20 --file= の値が秘密のファイル', G + ' -rn --file=' + SECRET + ' ' + SRC),
|
|
281
|
+
('i21 --file 空白の値が秘密のファイル(前からの形)', G + ' -rn --file ' + SECRET + ' ' + SRC),
|
|
282
|
+
('i22 別の道具の --regexp= +秘密のファイル', RG + ' -n --regexp=needle ' + SECRET),
|
|
283
|
+
]
|
|
284
|
+
for label, cmd in DANGER_KEEP:
|
|
285
|
+
check(label, kind(cmd), 'deny:danger')
|
|
286
|
+
|
|
287
|
+
# ═════════════════════════════════════════════════════════════════════════════
|
|
288
|
+
# (e) 秘密の名指し・倒す判定は今までどおり止まる(★1つも緩めない)
|
|
289
|
+
# ═════════════════════════════════════════════════════════════════════════════
|
|
290
|
+
print('── (e) 止める側は1つも緩めない ' + '─' * 34)
|
|
291
|
+
STOP = [
|
|
292
|
+
('e1 形Aの書き方+秘密のファイルを名指し',
|
|
293
|
+
G + ' -n ' + DQ + 'x ' + WORD + "\\|y' " + SECRET),
|
|
294
|
+
('e2 形Aの書き方+秘密のファイル(-e つき)',
|
|
295
|
+
G + ' -rn -e ' + DQ + 'x ' + WORD + "\\|y' " + SECRET),
|
|
296
|
+
('e3 形Aの書き方+秘密のファイル($"…")',
|
|
297
|
+
G + ' -rn ' + DD + 'x ' + WORD + '\\|y" ' + SECRET),
|
|
298
|
+
('e4 形Aの書き方で作業場所の根を探す',
|
|
299
|
+
G + ' -rn ' + DQ + 'x ' + WORD + "\\|y' " + SITE),
|
|
300
|
+
('e5 形Aの書き方で探す場所を書かない',
|
|
301
|
+
G + ' -rn ' + DQ + 'x ' + WORD + "\\|y'"),
|
|
302
|
+
('e6 形Aの書き方で点1つ',
|
|
303
|
+
G + ' -rn ' + DQ + 'x ' + WORD + "\\|y' ."),
|
|
304
|
+
('e7 形Aの書き方で秘密を含むフォルダを名指し',
|
|
305
|
+
G + ' -rn ' + DQ + 'x ' + WORD + "\\|y' " + WITHSECRET),
|
|
306
|
+
('e8 形Aの書き方で実在しない場所を名指し',
|
|
307
|
+
G + ' -rn ' + DQ + 'x ' + WORD + "\\|y' " + os.path.join(SITE, 'nosuch')),
|
|
308
|
+
('e9 形Aの書き方でしるし(*)を含む場所',
|
|
309
|
+
G + ' -rn ' + DQ + 'x ' + WORD + "\\|y' " + os.path.join(SITE, 'src', '*.ts')),
|
|
310
|
+
('e10 探す文字がファイルに在る旗(-f の値が秘密)',
|
|
311
|
+
G + ' -rn -f ' + SECRET + ' ' + SRC),
|
|
312
|
+
('e11 形Aの書き方で記録の外まで読む旗つき・場所なし',
|
|
313
|
+
GG + ' --untracked -n ' + DQ + 'x ' + WORD + "\\|y'"),
|
|
314
|
+
('e12 find で秘密のファイルを名指し', FIND + ' ' + SECRET + ' -exec ' + READ + ' {} +'),
|
|
315
|
+
('e13 find で秘密のファイルを名前で並べて渡す', FIND + ' ' + SECRET + ' | xargs ' + READ),
|
|
316
|
+
('e14 find で普通のファイルと秘密のファイルを並べる',
|
|
317
|
+
FIND + ' ' + FILE1 + ' ' + SECRET + ' -exec ' + READ + ' {} +'),
|
|
318
|
+
('e15 find の -exec の側に秘密のファイルを書く',
|
|
319
|
+
FIND + ' ' + FILE1 + ' -exec ' + READ + ' ' + SECRET + ' +'),
|
|
320
|
+
('e16 find で秘密を含むフォルダを名指し',
|
|
321
|
+
FIND + ' ' + WITHSECRET + ' -exec ' + READ + ' {} +'),
|
|
322
|
+
('e17 find で秘密を含むフォルダとファイルを並べる',
|
|
323
|
+
FIND + ' ' + WITHSECRET + ' ' + FILE1 + ' -exec ' + READ + ' {} +'),
|
|
324
|
+
('e18 find で作業場所の根', FIND + ' ' + SITE + ' -exec ' + READ + ' {} +'),
|
|
325
|
+
('e19 find で場所を書かない', FIND + ' -name x -exec ' + READ + ' {} +'),
|
|
326
|
+
('e20 find で実在しない場所を名指し',
|
|
327
|
+
FIND + ' ' + os.path.join(SITE, 'nosuch') + ' -exec ' + READ + ' {} +'),
|
|
328
|
+
('e21 秘密のファイルを読む(別の動詞)', READ + ' ' + SECRET),
|
|
329
|
+
]
|
|
330
|
+
for label, cmd in STOP:
|
|
331
|
+
check(label, kind(cmd), 'deny:danger')
|
|
332
|
+
check('e22 形Bの理由は本物の秘密の名前を指す',
|
|
333
|
+
NPMRC in reason(FIND + ' ' + SECRET + ' -exec ' + READ + ' {} +'), True)
|
|
334
|
+
check('e23 倒した旨の注は今までどおり出る',
|
|
335
|
+
'探す場所を書いていない' in reason(G + ' -rn ' + DQ + 'x ' + WORD + "\\|y'"), True)
|
|
336
|
+
|
|
337
|
+
# ═════════════════════════════════════════════════════════════════════════════
|
|
338
|
+
# (f) 同じ行に混ざった別の危険は、今までどおり先に当たる
|
|
339
|
+
# ═════════════════════════════════════════════════════════════════════════════
|
|
340
|
+
print('── (f) 混ざった形は今までどおり止まる ' + '─' * 28)
|
|
341
|
+
MIXED = [
|
|
342
|
+
('f1 形Aのあとで秘密を読む',
|
|
343
|
+
G + ' -rn ' + DQ + 'x ' + WORD + "\\|y' " + SRC + '; ' + READ + ' ' + SECRET),
|
|
344
|
+
('f2 形Bのあとで強い上書きの push',
|
|
345
|
+
FIND + ' ' + FILE1 + ' -exec ' + READ + ' {} + && git push --force origin main'),
|
|
346
|
+
('f3 形Bのあとで根を find',
|
|
347
|
+
FIND + ' ' + FILE1 + ' -exec ' + READ + ' {} + ; ' + FIND + ' ' + SITE
|
|
348
|
+
+ ' -exec ' + READ + ' {} +'),
|
|
349
|
+
('f4 形Aのあとで変数を含む再帰の削除',
|
|
350
|
+
G + ' -rn ' + DQ + 'x ' + WORD + "\\|y' " + SRC + ' && rm -r "$DIR/x"'),
|
|
351
|
+
('f5 形Bのあとでフォルダごとの複製',
|
|
352
|
+
FIND + ' ' + FILE1 + ' -exec ' + READ + ' {} + ; cp -r ' + SITE + ' /tmp/claude-1000/c'),
|
|
353
|
+
]
|
|
354
|
+
for label, cmd in MIXED:
|
|
355
|
+
check(label, kind(cmd), 'deny:danger')
|
|
356
|
+
|
|
357
|
+
# ═════════════════════════════════════════════════════════════════════════════
|
|
358
|
+
# (g) 部品の単体
|
|
359
|
+
# ═════════════════════════════════════════════════════════════════════════════
|
|
360
|
+
print('── (g) 部品の単体 ' + '─' * 54)
|
|
361
|
+
NAIVE = [
|
|
362
|
+
('g1 引用符が閉じていない区切りは素朴分割へ倒れる', G + " -rn 'a b\\", True),
|
|
363
|
+
('g2 $'"'"'…\' で閉じていない区切りも倒れる', G + ' -rn ' + DQ + 'a b\\', True),
|
|
364
|
+
('g3 引用符が閉じている区切りは倒れない', G + " -rn 'a b' " + SRC, False),
|
|
365
|
+
('g4 引用符が無い区切りは倒れない', G + ' -rn abc ' + SRC, False),
|
|
366
|
+
('g5 途中に引用符が1つ入る形は倒れない', G + ' -rn "it' + Q + 's" ' + SRC, False),
|
|
367
|
+
('g6 空の字面', '', False),
|
|
368
|
+
('g7 None', None, False),
|
|
369
|
+
]
|
|
370
|
+
for label, seg, want in NAIVE:
|
|
371
|
+
check(label, policy.naive_token_split(seg), want)
|
|
372
|
+
|
|
373
|
+
SPAN = [
|
|
374
|
+
('g8 倒れたときは引用符が閉じるまで外す',
|
|
375
|
+
['-n', DQ + 'a', 'b', 'c'], 1, True, [1, 2, 3]),
|
|
376
|
+
('g9 倒れたときは閉じる所で止まる',
|
|
377
|
+
['-n', DQ + 'a', "b'", 'c'], 1, True, [1, 2]),
|
|
378
|
+
('g10 倒れたとき・引用符で始まる語(前からの形)',
|
|
379
|
+
['-n', "'a", 'b'], 1, True, [1, 2]),
|
|
380
|
+
('g11 倒れたとき・引用符が無い語は1語だけ', ['-n', 'a', 'b'], 1, True, [1]),
|
|
381
|
+
('g12 倒れていなければ続きを1つも外さない',
|
|
382
|
+
['-n', DQ + 'a', 'b', 'c'], 1, False, [1]),
|
|
383
|
+
('g13 倒れていなければ引用符で始まる語でも1語だけ',
|
|
384
|
+
['-n', "'a", 'b'], 1, False, [1]),
|
|
385
|
+
]
|
|
386
|
+
for label, args, first, naive, want in SPAN:
|
|
387
|
+
check(label, policy._pattern_word_positions(args, first, naive=naive), want)
|
|
388
|
+
|
|
389
|
+
POS = [
|
|
390
|
+
('g14 倒れた区切りを渡すと続きも外す', 'grep', ['-n', DQ + 'a', 'b.ts'], '"', {1, 2}),
|
|
391
|
+
('g15 倒れていない区切りでは外さない', 'grep', ['-n', DQ + 'a', 'b.ts'], None, {1}),
|
|
392
|
+
('g16 -f が在れば倒れていても1つも外さない',
|
|
393
|
+
'grep', ['-f', 'p.txt', DQ + 'a', 'b.ts'], '"', set()),
|
|
394
|
+
('g17 探す道具でなければ1つも外さない', 'cat', [DQ + 'a', 'b.ts'], '"', set()),
|
|
395
|
+
]
|
|
396
|
+
for label, verb, args, seg, want in POS:
|
|
397
|
+
check(label, set(policy.pattern_arg_positions(verb, args, seg)), want)
|
|
398
|
+
|
|
399
|
+
check('g18 実在のファイルはその場所を返す', policy._existing_file(FILE1, SITE),
|
|
400
|
+
os.path.realpath(FILE1))
|
|
401
|
+
check('g19 実在のフォルダはファイルではない', policy._existing_file(SRC, SITE), None)
|
|
402
|
+
check('g20 実在しない名前は返さない', policy._existing_file('nosuch.ts', SITE), None)
|
|
403
|
+
|
|
404
|
+
# ═════════════════════════════════════════════════════════════════════════════
|
|
405
|
+
# (h) 空振り確認(直しを外すと、この台本が落ちる)
|
|
406
|
+
# ═════════════════════════════════════════════════════════════════════════════
|
|
407
|
+
print('── (h) 空振り確認(直しを外すと落ちる) ' + '─' * 32)
|
|
408
|
+
_real_span = policy._pattern_word_positions
|
|
409
|
+
_real_file = policy._existing_file
|
|
410
|
+
|
|
411
|
+
A_FORM = G + ' -n ' + DQ + 'env: ' + WORD + "\\|home:' " + FILE1
|
|
412
|
+
B_FORM = FIND + ' ' + FILE1 + ' -exec ' + READ + ' {} +'
|
|
413
|
+
C_FORM = G + ' -rn "' + Q + '" ' + SRC
|
|
414
|
+
H_FORM = G + ' -n "' + Q + '" ' + SECRET
|
|
415
|
+
|
|
416
|
+
|
|
417
|
+
def _old_span(args, first, word=None, naive=False):
|
|
418
|
+
"""直す前の読み方(最初の語が引用符そのもので始まるときだけ続きを外す・便 18e9e32e)。"""
|
|
419
|
+
out = [first]
|
|
420
|
+
word = args[first] if word is None else word
|
|
421
|
+
if word[:1] not in ('"', "'"):
|
|
422
|
+
return out
|
|
423
|
+
quote = policy._open_quote(word)
|
|
424
|
+
i = first + 1
|
|
425
|
+
while quote and i < len(args):
|
|
426
|
+
out.append(i)
|
|
427
|
+
quote = policy._open_quote(args[i], quote)
|
|
428
|
+
i += 1
|
|
429
|
+
return out
|
|
430
|
+
|
|
431
|
+
|
|
432
|
+
policy._pattern_word_positions = _old_span
|
|
433
|
+
check('h1 旧い読み方に戻すと形Aが止まる', kind(A_FORM), 'deny:danger')
|
|
434
|
+
check('h2 旧い読み方に戻すと形Cも止まる', kind(C_FORM), 'deny:danger')
|
|
435
|
+
check('h3 旧い読み方に戻すと穴Hが通ってしまう', kind(H_FORM), 'allow')
|
|
436
|
+
check('h4 旧い読み方でも形Bは別の直し(通ったまま)', kind(B_FORM), 'allow')
|
|
437
|
+
policy._pattern_word_positions = _real_span
|
|
438
|
+
|
|
439
|
+
policy._existing_file = lambda arg, cwd=None: None
|
|
440
|
+
check('h5 実在のファイルを読まない作りに戻すと形Bが止まる', kind(B_FORM), 'deny:danger')
|
|
441
|
+
check('h6 そのときも形Aは通る(2つの原因は別物)', kind(A_FORM), 'allow')
|
|
442
|
+
policy._existing_file = _real_file
|
|
443
|
+
|
|
444
|
+
check('h7 戻したら4つの形が期待どおり',
|
|
445
|
+
(kind(A_FORM), kind(B_FORM), kind(C_FORM), kind(H_FORM)),
|
|
446
|
+
('allow', 'allow', 'allow', 'deny:danger'))
|
|
447
|
+
|
|
448
|
+
#: 形D の空振り(繋げた書き方を読む部品を外すと、名指しの場所が探す文字として捨てられる)
|
|
449
|
+
_real_joined = policy._disc_pattern_joined
|
|
450
|
+
D_FORM = G + ' -rn --regexp=needle ' + SRC
|
|
451
|
+
D_STOP = G + ' -rn --regexp=needle'
|
|
452
|
+
|
|
453
|
+
policy._disc_pattern_joined = lambda w: False
|
|
454
|
+
check('h8 繋げた書き方を読まない作りに戻すと形Dが止まる', kind(D_FORM), 'deny:discipline')
|
|
455
|
+
check('h9 そのときも形A・形Bは通る(原因が別物)', (kind(A_FORM), kind(B_FORM)),
|
|
456
|
+
('allow', 'allow'))
|
|
457
|
+
policy._disc_pattern_joined = _real_joined
|
|
458
|
+
|
|
459
|
+
check('h10 戻したら形Dは通り、場所を書かない形は止まる',
|
|
460
|
+
(kind(D_FORM), kind(D_STOP, PLAIN)), ('allow', 'deny:discipline'))
|
|
461
|
+
|
|
462
|
+
# ─────────────────────────────────────────────────────────────────────────────
|
|
463
|
+
# ★作り物を片付ける(使い捨ての場所に残骸を残さない・便 de82bc3a のコミット a5118c7 と同じ作法)
|
|
464
|
+
import shutil # noqa: E402
|
|
465
|
+
|
|
466
|
+
shutil.rmtree(ROOT, ignore_errors=True)
|
|
467
|
+
check('z1 作り物を片付けた', os.path.isdir(ROOT), False)
|
|
468
|
+
|
|
469
|
+
print()
|
|
470
|
+
if failures:
|
|
471
|
+
print(f'NG {len(failures)} 件')
|
|
472
|
+
for line in failures:
|
|
473
|
+
print(' ' + line)
|
|
474
|
+
sys.exit(1)
|
|
475
|
+
print('すべて OK')
|
|
@@ -227,6 +227,11 @@ check('f5 途中の引用符でも秘密を名指しすれば止まる', kind(G
|
|
|
227
227
|
# (g) 部品の単体
|
|
228
228
|
# ═════════════════════════════════════════════════════════════════════════════
|
|
229
229
|
print('── (g) 部品の単体 ' + '─' * 54)
|
|
230
|
+
#: ★語の割り方が素朴分割へ倒れた区切り(引用符が閉じていない)を表す字面。
|
|
231
|
+
# 便 362a7759 から、割れた探す言葉の続きを外すかは「倒れたかどうか」で決まるので、
|
|
232
|
+
# 割れた語の並びを渡す行には、倒れた区切りの字面も一緒に渡す(前提データ)。
|
|
233
|
+
BROKEN = '"'
|
|
234
|
+
#: (番号と何の形か, 動詞, 語の並び, 外す位置, 測っている区切りの字面)
|
|
230
235
|
POS = [
|
|
231
236
|
('g1 旗でない最初の引数が探す文字', 'grep', ['-n', 'needle', 'a.ts'], {1}),
|
|
232
237
|
('g2 探す道具でなければ1つも外さない', 'cat', ['needle', 'a.ts'], set()),
|
|
@@ -241,22 +246,24 @@ POS = [
|
|
|
241
246
|
('g10 引数が旗だけ', 'grep', ['-rn'], set()),
|
|
242
247
|
('g11 引数が無い', 'grep', [], set()),
|
|
243
248
|
('g12 閉じていない引用符で始まる語は続きも外す',
|
|
244
|
-
'grep', ['-n', "'env: " + WORD, 'rest'], {1, 2}),
|
|
249
|
+
'grep', ['-n', "'env: " + WORD, 'rest'], {1, 2}, BROKEN),
|
|
245
250
|
('g13 引用符で始まらない語は続きを外さない', 'grep', ['-n', 'env:', WORD], {1}),
|
|
246
251
|
('g14 引用符が閉じている語は続きを外さない', 'grep', ['-n', "'a'", 'a.ts'], {1}),
|
|
247
252
|
('g15 閉じていない語が閉じる所まで外す',
|
|
248
|
-
'grep', ['-n', '"a', 'b"', 'a.ts'], {1, 2}),
|
|
253
|
+
'grep', ['-n', '"a', 'b"', 'a.ts'], {1, 2}, BROKEN),
|
|
249
254
|
('g16 -e の値も引用符が閉じるまで外す(値が割れる形)',
|
|
250
|
-
'grep', ['-e', '"a', 'b"', 'a.ts'], {1, 2}),
|
|
255
|
+
'grep', ['-e', '"a', 'b"', 'a.ts'], {1, 2}, BROKEN),
|
|
251
256
|
('g17 -e の値が閉じていなければ残りが全部探す文字',
|
|
252
|
-
'grep', ['-e', "'a", 'b', 'c'], {1, 2, 3}),
|
|
257
|
+
'grep', ['-e', "'a", 'b', 'c'], {1, 2, 3}, BROKEN),
|
|
253
258
|
('g18 -e の値が引用符で始まらなければ値1語だけ',
|
|
254
259
|
'grep', ['-e', 'a', 'b.ts'], {1}),
|
|
255
260
|
('g19 --regexp= の値が割れる形(旗の部分は見ない)',
|
|
256
|
-
'grep', ['--regexp="a', 'b"', 'a.ts'], {0, 1}),
|
|
261
|
+
'grep', ['--regexp="a', 'b"', 'a.ts'], {0, 1}, BROKEN),
|
|
257
262
|
]
|
|
258
|
-
for
|
|
259
|
-
|
|
263
|
+
for row in POS:
|
|
264
|
+
label, verb, args, want = row[:4]
|
|
265
|
+
seg = row[4] if len(row) > 4 else None
|
|
266
|
+
check(label, set(policy.pattern_arg_positions(verb, args, seg)), want)
|
|
260
267
|
|
|
261
268
|
QUOTE = [
|
|
262
269
|
('h1 単引用符が開いたまま', "'env: " + WORD, None, "'"),
|
|
@@ -274,11 +281,11 @@ for label, text, state, want in QUOTE:
|
|
|
274
281
|
check(label, policy._open_quote(text, state), want)
|
|
275
282
|
|
|
276
283
|
check('h11 探す言葉の語の広がり(閉じていない)',
|
|
277
|
-
policy._pattern_word_positions(['-n', "'a", 'b', 'c'], 1), [1, 2, 3])
|
|
284
|
+
policy._pattern_word_positions(['-n', "'a", 'b', 'c'], 1, naive=True), [1, 2, 3])
|
|
278
285
|
check('h12 探す言葉の語の広がり(閉じる所で止まる)',
|
|
279
|
-
policy._pattern_word_positions(['-n', "'a", "b'", 'c'], 1), [1, 2])
|
|
286
|
+
policy._pattern_word_positions(['-n', "'a", "b'", 'c'], 1, naive=True), [1, 2])
|
|
280
287
|
check('h13 探す言葉の語の広がり(引用符で始まらない)',
|
|
281
|
-
policy._pattern_word_positions(['-n', 'a', 'b'], 1), [1])
|
|
288
|
+
policy._pattern_word_positions(['-n', 'a', 'b'], 1, naive=True), [1])
|
|
282
289
|
|
|
283
290
|
# ═════════════════════════════════════════════════════════════════════════════
|
|
284
291
|
# (h) 空振り確認(直しを外すと、この台本が落ちる)
|
|
@@ -288,7 +295,7 @@ _real_positions = policy.pattern_arg_positions
|
|
|
288
295
|
_real_span = policy._pattern_word_positions
|
|
289
296
|
|
|
290
297
|
|
|
291
|
-
def _old_positions(verb, args):
|
|
298
|
+
def _old_positions(verb, args, seg=None):
|
|
292
299
|
"""直す前の読み方(最初の1語だけを外す・-e / -f が在れば1つも外さない)。"""
|
|
293
300
|
if verb not in policy._PATTERN_FIRST_VERBS:
|
|
294
301
|
return frozenset()
|
|
@@ -312,7 +319,9 @@ check('i3 直す前の読み方でも秘密の名指しは止まる(守りは
|
|
|
312
319
|
kind(G + " -n 'x' " + SECRET), 'deny:danger')
|
|
313
320
|
policy.pattern_arg_positions = _real_positions
|
|
314
321
|
|
|
315
|
-
policy._pattern_word_positions =
|
|
322
|
+
policy._pattern_word_positions = (
|
|
323
|
+
lambda args, first, word=None, naive=False: [first] # ①だけを外す
|
|
324
|
+
)
|
|
316
325
|
check('i4 ①を外すと空白+当て字の縦棒の形が止まる',
|
|
317
326
|
kind(G + " -n 'env: " + WORD + "\\|home:' " + FILE1), 'deny:danger')
|
|
318
327
|
check('i5 ①を外しても -e の形は通る(②は別の直し)',
|
|
@@ -189,6 +189,10 @@ description: 采配くんの便(プロンプト末尾に CONDUCTOR_JOB:<id>
|
|
|
189
189
|
- ★**名指しの先が「ファイル1つ」なら通る**(`grep -rn 'relay' src/relay.ts`・2026-10-10 の便 3be099ba で直した)。前は再帰の旗が付いているだけで作業場所(リポの根)に倒れ、根の秘密ファイルに当たって止まっていた(実地 便 1ff7b915)。★**秘密の名前のファイルを名指しすれば今までどおり止まる。**
|
|
190
190
|
- ★**探す言葉に当て字の縦棒(`\|`)を入れた形も、名指しの場所で判定される**(`grep -rn "a\|b" services packages`・同じ便で直した)。前は引用符の中で命令が千切れて場所が別の切れ端へ移り、作業場所に倒れて止まっていた(実地 便 3bbde2e3)。★**場所を書かない形**(`grep -rn "a\|b"` だけ)は今までどおり止まる。
|
|
191
191
|
- ★**探す言葉が「`.env` で終わって見える語」を含む形も通る**(`grep -n 'env: process.env\|home:' src/selfcheck.ts`・`grep -n -e 'env: process.env' -e 'home:' src/selfcheck.ts`・2026-10-11 の便 18e9e32e で直した)。前は**探す言葉がパスとして測られ**、その語が秘密のファイルに見えて止まっていた(実地 便 3f54ac4a)。★**秘密の名前のファイルを名指しすれば今までどおり止まる**(`grep -n 'x' .env`・`grep -n -e 'x' .env`)。
|
|
192
|
+
- ★**引用符で始まらない囲みで割れた探す言葉も通る**(`grep -n $'env: process.env\|home:' src/selfcheck.ts`・`grep -rn $"x process.env\|y" src`・`grep -rn x'y process.env\|z' src`・2026-10-12 の便 362a7759 で直した)。前は、割れたかどうかを「探す言葉が引用符そのもので始まるか」で見ていたので、`$'…'` のように引用符で始まらない書き方では続きを外せず、割れた2語目がパスとして測られて止まっていた。★**秘密の名前のファイルを名指しすれば今までどおり止まる。**
|
|
193
|
+
- ★**探す言葉を `=` で繋げた旗で渡す形も、名指しの場所で判定される**(`grep -rn --regexp='x\|y' src`・`grep -rn --file=patterns.txt src`・2026-10-12 の便 220a1e2c で直した)。前は**名指しの探す場所が探す言葉と取り違えられ**、場所を書かない全体の再帰検索として止まっていた(★探す言葉の中身とは関係なく、普通の語でも止まった)。★**場所を書かない形**(`grep -rn --regexp='x'` だけ)は今までどおり止まる。
|
|
194
|
+
- ★**名指しのファイルを `find` から読む道具へ渡す形も通る**(`find src/selfcheck.ts -exec cat {} +`・`find src/a.ts | xargs cat`・`find src/a.ts -type f -exec grep -n x {} +`・2026-10-12 の便 362a7759 で直した)。前は、探す場所を実在のフォルダだけで集めていたので、ファイルを名指しした形が作業場所(リポの根)に倒れ、根の秘密ファイルに当たって止まっていた。★**秘密の名前のファイルを名指しすれば今までどおり止まる**(`find .npmrc -exec cat {} +`)。
|
|
195
|
+
- ★**探す言葉が引用符で始まる形で、名指しの場所まで食われることは無くなった**(`grep -rn "'a" src` が通る・同じ便で直した)。★**その書き方で秘密のファイルを名指しする形は、前は通っていたが今は止まる**(`grep -n "'a" .npmrc`=止め漏れを塞いだ)。
|
|
192
196
|
- ★**記録の外まで読む旗を付けた形は止まる**(`git grep --untracked`・`--no-index`・`--no-exclude-standard`)。実測で、この旗を付けると追跡していない秘密のファイルまで中身が出る(便 227aeebb)。追跡済みだけを見る素の `git grep` は今までどおり通る。
|
|
193
197
|
- ★**名前を並べて別の道具へ渡す形も止まる**(`find <場所> -type f -exec cat {} +`・`find <場所> | xargs rg`・包みの中に入れた同じ形)。探した場所の中に秘密のファイルが在るときだけ止まる(便 227aeebb)。
|
|
194
198
|
- ★**除外指定では通らない**(実測 2026-09-27)。`grep -rn 語 . --exclude=.npmrc` は、`.` の再帰でまず止まり、さらに**秘密のファイル名を引数に書いた事自体**でも止まる。「除いて探す」ではなく「場所を名指しする」が正解。
|