1
1

Delete article

Deleted articles cannot be recovered.

Draft of this article would be also deleted.

Are you sure you want to delete this article?

gitが使えない職場のzipやり取りに、3-wayマージだけを持ち込む

1
Last updated at Posted at 2026-08-25

「ソースコードは zip で送ってください」と言われる職場がある。
git が入っていない、入れられない、あるいは使ってよいことになっていない。
そういう環境で 2 人以上が同じコードを触ると、最後に必ず「取り込み」で詰まる。

この記事は、その取り込みだけを解決する道具の話です。
git の代わりを作ろうとはしていません。履歴管理もブランチもリモート同期も捨てて、
統合の一点だけ を持ち込みます。

コードは記事の最後に全部貼ってあります。外部パッケージには依存しません。
必要なのは Python 3.8 以上だけです。
AI使ってます。

何が起きているか

zip をやり取りしていると、返ってきたコードを取り込む時点でこうなります。

  • どちらが変更した行なのか分からない
  • 目視でマージした結果、片方の修正を黙って捨てる
  • CRLF と Shift_JIS が混ざり、1 行も変えていないのに全ファイルが差分になる

3 つ目が特にたちが悪い。差分ツールが真っ赤になるので、
「全部変わっている」と思って相手の版をまるごと上書きし、自分の修正を失います。

中核の判断:base があるかどうかで全部決まる

統合の精度は、賢いマージアルゴリズムでは決まりません。
共通の出発点(base)を持てるかどうか で決まります。

base なし (2-way) base あり (3-way)
「Aの3行目」と「Bの3行目」が違うとき どちらが変更側か原理的に判別不能 base と比較すれば一意に決まる
人間の判断が必要な箇所 差分の 全部 両者が 同じ行 を別々に変えた箇所のみ
実務での自動化率 0% 概ね 80〜90%

これは実装の工夫の差ではなく、情報量の差 です。
base が無ければ、どんなに賢いアルゴリズムでも「どちらが変えたか」は決められません。
逆に base さえあれば、素朴な実装でも 8〜9 割が自動で片付きます。

git が強いのは分散管理だからではなく、base を常に持っているから です。
なので、模倣するのはそこだけでいい。構成は 2 層になります。

  • 層1: スナップショット — 渡す前の状態を .likegit/snapshots/ に退避
  • 層2: マージエンジン — 3-way マージ(base が無ければ 2-way にフォールバック)

使い方

1. 渡す前に控えを取る

これを忘れると 2-way に落ちて自動化率が 0 になります。 一番大事な操作です。

python -m likegit snapshot ./src -m "Aさんに渡す前"
退避しました: 20260825-103000_Aさんに渡す前
  元       : C:\work\myproject\src
  保存先   : C:\work\myproject\.likegit\snapshots\20260825-103000_Aさんに渡す前
  ファイル : 42 件

統合時は  --base 20260825-103000_Aさんに渡す前  と指定してください。

控えはただのファイルコピーとして置かれます。独自形式は使っていないので、
エクスプローラで開いて中身を確認できます。壊れても手で救出できることを優先しました。

2. それぞれ編集する

自分は ./src を、相手は渡したコピーを編集します。

3. 受け取って統合する

python -m likegit merge --base 20260825-103000_Aさんに渡す前 ^
                        --mine ./src --theirs ./from_A --out ./merged
likegit merge レポート
  base   : 20260825-103000_Aさんに渡す前
  mine   : C:\work\myproject\src
  theirs : C:\work\myproject\from_A
  out    : C:\work\myproject\merged
  日時   : 2026-08-25T14:22:10

[衝突] 2 件 -- 手で直してください
  app.py    衝突            1 箇所 (行 12)
  book.xlsx 衝突(バイナリ)  1 箇所
              - バイナリのため自動統合不可。相手の版を book.THEIRS.xlsx に置きました

[集計]
  変更なし        36
  自動マージ       3
  相手の版を採用   1
  相手が追加       1
  衝突             1
  衝突(バイナリ)   1
  合計            43

結果: 衝突 2 ファイル / 2 箇所。C:\work\myproject\merged を開いて <<<<<<< を解決してください。

--mine と --theirs は絶対に書き換えません。結果は必ず第 3 の場所に出ます。

4. 衝突を直す

def calc(x):
<<<<<<< MINE
    return x * 3
=======
    return x * 4
>>>>>>> THEIRS

どちらを採るか決めて、マーカー 3 行ごと消します。

終了コードは「衝突なし=0 / 衝突あり=1 / エラー=2」なので、
バッチファイルから if errorlevel 1 で分岐できます。

実装で効いた落とし穴 3 つ

ここからが本題です。動くものを作るだけなら difflib で 100 行ですが、
実務で使うと以下で必ず転びます。

1. autojunk=False を付けないと差分が壊滅する

マージの中核は difflib.SequenceMatcher を base↔mine と base↔theirs で 2 本回し、
両者が同時に base と一致している区間(同期区間) を求める処理です。

a_blocks = SequenceMatcher(None, base, mine, autojunk=False).get_matching_blocks()
b_blocks = SequenceMatcher(None, base, theirs, autojunk=False).get_matching_blocks()

この autojunk=False が必須です。

既定の autojunk は「要素数が 200 を超えたとき、全体の 1% 以上に出現する要素を
ノイズ扱いして無視する」というヒューリスティックです。
散文なら妥当ですが、ソースコードには空行や } や が大量にあります。
これらがノイズ扱いされると同期区間が取れなくなり、
本来自動でマージできるはずの変更がまとめて衝突になります。

200 行を超えたあたりから急に品質が落ちるので、小さいファイルでテストしていると気づけません。
テストもその規模で書く必要があります。

def test_repeated_blank_lines_do_not_break_diff(self):
    block = ["", "}"] * 150          # 300 要素。これ未満だと再現しない
    base   = ["header"] + block + ["tail"]
    mine   = ["header"] + block + ["tail-mine"]
    theirs = ["HEADER"] + block + ["tail"]
    self.assertEqual(diff3.count_conflicts(diff3.merge3(base, mine, theirs)), 0)

2. utf-8-sig を判定候補の先頭に置いてはいけない

日本語 Windows では文字コードを推定するしかありません。素直に書くとこうなります。

CANDIDATE_ENCODINGS = ("utf-8-sig", "utf-8", "cp932", "euc_jp")   # ← これは罠

def decode(data):
    for enc in CANDIDATE_ENCODINGS:
        try:
            return data.decode(enc), enc
        except UnicodeDecodeError:
            continue

私はこれを書いて、実際にバグを踏みました。

utf-8-sig は BOM が無いバイト列も問題なく復号します。
BOM があれば剥がす、無ければそのまま読む、という codec だからです。
結果、候補の先頭に置くと BOM の無いファイルまで utf-8-sig と判定され、
その情報で保存し直したときに BOM が付き足されます。

つまり、「1 行も変えていないのに全体が差分になる」事故を防ぐために作ったツールが、
自分でその事故を起こしていました。しかも先頭 3 バイトなので、
エディタで開いても気づきにくい。

正しくは、BOM の有無を候補試行に混ぜず、先に直接見ます。

CANDIDATE_ENCODINGS = ("utf-8", "cp932", "euc_jp")

def decode(data):
    if data.startswith(codecs.BOM_UTF8):
        return data.decode("utf-8-sig"), "utf-8-sig"
    for enc in CANDIDATE_ENCODINGS:
        ...

残りの順序にも意味があります。UTF-8 として妥当なバイト列が CP932 としても妥当な
ことは稀なので、UTF-8 を先に試すのが安全側です。逆順にすると、
UTF-8 の日本語が化けたまま「読めた」ことになります。

そして比較と保存を分離します。

  • 比較時: 改行コードを剥がした「行の配列」に正規化 → 改行差が差分から消える
  • 保存時: 元ファイルの改行コード・エンコーディング・BOM・末尾改行を復元

なお str.splitlines() は使えません。\x0b や \u2028 でも分割するため、
"\n" で繋ぎ直すとファイルが壊れます。改行コードだけを対象にした正規表現で分割します。

3. 隣り合った変更は衝突になる(git と同じ)

3-way マージを実装すると、こういう入力で「なぜ衝突するのか」と悩みます。

base:   one    mine:   ONE    theirs: one
        two            two            TWO

片方が 1 行目、もう片方が 2 行目を変えただけなので、
ONE / TWO に自動マージされてほしい。でも衝突になります。

同期区間は「両者が同時に base と一致する区間」です。
1 行目は mine が変えたので同期しない。2 行目は theirs が変えたので同期しない。
つまり同期点が 1 つも無く、ファイル全体が 1 つの不安定区間になります。

ここで「もっと賢くしよう」と手を入れたくなりますが、やめました。
git merge-file に同じ入力を与えると、まったく同じ衝突を出します。

$ printf 'one\ntwo\n' > base.txt
$ printf 'ONE\ntwo\n' > mine.txt
$ printf 'one\nTWO\n' > theirs.txt
$ git merge-file -p mine.txt base.txt theirs.txt
<<<<<<< mine.txt
ONE
two
=======
one
TWO
>>>>>>> theirs.txt
$ echo $?
1

自動化率をわずかに上げるために git と挙動を変えると、
「git なら通るのに」という食い違いが事故になります。
古典的 diff3 の性質として受け入れ、テストとドキュメントに「仕様」として書きました。

安全側に倒す

git が無い環境では取り消しが効きません。ここは厚くしました。

  1. --mine と --theirs は書き換えない。出力は必ず第 3 の場所
  2. --out が空でなければ拒否(--force で上書き許可)
  3. --out が --mine / --theirs / base の中を指していたら拒否
  4. --mine / --theirs / base が互いに入れ子なら拒否(走査結果が混ざるため)
  5. --in-place は必ず先に .likegit/backups/ へ退避してから書き込む
  6. --dry-run は書き込みゼロ。レポートも残さない
  7. 元ファイルに <<<<<<< があれば警告する
  8. 書き込みは全ファイルの判定を終えてから始める
  9. 1 件も退避できなかった snapshot は成功にしない(後述)

設計としては、「何を書くか」を決める計画フェーズと、実際に書く実行フェーズを
分離
しています。

plan = merger.plan_tree(base, mine, theirs, options)   # ここでは 1 バイトも書かない
merger.apply(plan, out_root)                           # 書くのはここだけ

こうすると --dry-run が特別扱いなしに成立します(apply を呼ばないだけ)。
レポートも実行結果ではなく計画から作るので、--dry-run と本番でまったく同じ内容が出ます。

空ディレクトリの掃除で 1 つやらかした

--in-place でファイルを削除すると空フォルダが残るので掃除したくなります。
最初はこう書きました。

def _prune_empty_dirs(root):
    for dirpath, _, _ in os.walk(root, topdown=False):
        if not any(Path(dirpath).iterdir()):
            Path(dirpath).rmdir()          # ← 元から空だったフォルダも消える

置き場所として用意してあった logs/ のようなフォルダを巻き込みます。
しかも「なぜか動かない」という形で後から効いてくるので、原因が追いにくい。

自分が消したファイルの親だけを上へ辿る ように直しました。

「成功」と言ってはいけない場面がある

もう 1 つ、最後の点検で見つけたものです。
存在しないパスを指定したときや、.likegitignore が広すぎて全部を弾いたとき、
snapshot が 0 件で「退避しました」と表示して終了コード 0 を返して いました。

これは黙って通してはいけない類の失敗です。利用者は控えを取ったつもりで相手に
コードを渡し、統合の段になって全ファイルが衝突して初めて気づく。
しかもその時点では、もう base を取り直せません。ツールの前提そのものが
崩れているのに、成功に見える
のが最悪です。

0 件なら終了コード 2 で止めるようにしました。
古い空の base を --base に指定した merge 側でも、レポートに警告を出します。

「エラーではないが成功でもない」状態を成功として返さない、というのは
言われれば当たり前ですが、書いているときは気づきませんでした。

Windows の 260 文字制限

退避先は元のパスに .likegit/snapshots/<名前>/tree/ が付くぶん長くなります。
実測で 44 文字(メッセージ無し)〜77 文字(メッセージ 40 文字) 伸びます。

つまり 元ファイルは作れているのに退避先が 260 文字を超えて失敗する、
ということが階層の深いプロジェクトでは普通に起きます。
Java の src/main/java/com/company/... のようなツリーだと現実的な話です。

制限を外すレジストリ設定(LongPathsEnabled)は管理者権限が要るので、
社内 PC ではまず変更できません。使えるのは \\?\ 接頭辞のほうです。
これは そのパス 1 つだけ制限を外す もので、権限も設定変更も要りません。

def extend(path: Path) -> Path:
    if os.name != "nt":
        return path
    text = os.fspath(path)
    if text.startswith("\\\\?\\"):
        return path
    absolute = os.path.abspath(text)        # \\?\ 付きは OS 側で正規化されない
    if absolute.startswith("\\\\"):         # UNC (\\server\share)
        return Path("\\\\?\\UNC\\" + absolute[2:])
    return Path("\\\\?\\" + absolute)

方針は「I/O の直前だけで接頭辞を付け、保持・表示するパスは接頭辞なしのまま」です。
\\?\C:\... がレポートやエラーメッセージに出ると、読み手が混乱するので。

ここで恥ずかしい話をひとつ。実装中に
「pathlib は接頭辞を潰すから文字列で扱う必要がある」「os.makedirs は使えない」
という 2 つの前提を立てて、それに合わせた回避コードを一式書きました。

どちらも間違いでした。 検証に使ったシェルのヒアドキュメントが
バックスラッシュを 1 つ落としていて、\\?\ ではなく \?\ を渡していただけです。
実際には pathlib は接頭辞を保持し、mkdir(parents=True)・write_bytes・stat・
unlink・shutil.copy2・os.walk はいずれもそのまま動きます。

環境の挙動を疑う前に、自分が渡している値を確認する。
特にバックスラッシュとエスケープが絡むときは。

「情報が外に出ない」を実測する

業務コードを通すツールなので、通信しないことは設計上の要件です。
ソースを読めば分かることですが、持ち込みの可否を判断するのは書いた本人ではない ので、
提出できる形にしておきたい。

Python には sys.addaudithook があります。
CPython が内部で発火させる監査イベントを全部拾えるので、
socket を経由せず ctypes で叩くような細工もここに現れます。

$ python tools/audit.py

likegit 監査結果   (Python の監査フックで全イベントを捕捉)
==========================================================================
  通信          socket/urllib/http/smtp/asyncio ...
      likegit 由来:   0 件  [OK]      (参考) 標準ライブラリ内部: 0 件
  プロセス起動  subprocess/os.system/ctypes/winreg
      likegit 由来:   0 件  [OK]      (参考) 標準ライブラリ内部: 0 件
  動的コード実行 文字列の exec/eval, pickle.loads
      likegit 由来:   0 件  [OK]      (参考) 標準ライブラリ内部: 61 件
--------------------------------------------------------------------------
  likegit が書き込んだ先: 指定パス内 16 件 / 指定パス外 0 件  [OK]

判定: 完全ローカル。通信なし・指定パス外への書き込みなし。

作るときに 1 つ注意点がありました。
最初は雑に集計して「動的コード実行 131 件」と出て焦ったのですが、中身は全部

  • marshal.loads … .pyc の読み込み(import 機構)
  • compile … @dataclass が __init__ をソース文字列から生成している

でした。どちらも言語の側の動作です。
@dataclass を使っているとスタックに自分のフレームが残るので、
「スタックのどこかに自分がいるか」で判定すると自分のせいに見えます。
exec/compile については 直接の呼び出し元 で判定する必要がありました。

一方で通信やファイル書き込みは「自分が標準ライブラリ経由で起こした」ものを
捕まえたいので、スタック全体で見ます。目的によって判定を変える必要がある、
というのが実装上のポイントです。

ダウンロード禁止の環境へどうやって持ち込むか

ここが最後の関門です。ブラウザは通るがファイルのダウンロードは禁止、という環境がある。

20 個以上のファイルを 1 つずつコピペするのは現実的ではありません。
写し損ねに気づけない からです。1 ファイル欠けただけで ImportError なら
まだ幸運で、行が 1 行落ちただけだと動いてしまって後で壊れます。

なので、プロジェクト全体を 1 ファイルにまとめる仕組みを付けました。

python tools/bundle.py    ->  likegit_bundle.py (全 21 ファイル収録)

受け取る側は、記事の最後のコードブロックを丸ごとコピーして
likegit_bundle.py として保存し:

python likegit_bundle.py --verify   コピペで壊れていないか確認する
python likegit_bundle.py            ./likegit_project に展開する

各ファイルの SHA-256 を一緒に埋め込んである ので、
コピペで行が欠けたり空白が変わったりすれば --verify が検出します。
実際に 1 行削って試すと、こうなります。

!! このバンドルは壊れています。コピペで内容が変わった可能性があります。
   likegit/merger.py
     記録: 19cbd846f1a72fba73c85ce463381269f0f0f173b1db041513f0d34f89262b79
     実際: 2c86a42c13865737d42d3bce8da77b9af06211a9244648bd6ae5b75cfbf54a7a

   元のページからもう一度コピーし直してください。

意識したのは base64 にしないこと です。
読めない塊を「実行してください」と渡すのは、受け取る側にとって危険な形です。
素のソースのまま入れてあるので、展開する前に目で読めます。

作っている最中、この仕組み自身のバグを --verify が捕まえました。
生成側で末尾に改行を 1 つ余分に足していて、収録した最後のファイルだけ
ハッシュが合わなかった。1 文字の間違いですが、
検証を付けていなければ気づかないまま配っていたはずです。

動作確認

展開したら、3 つとも終了コードで判定できます。

python -m unittest discover -s tests   テスト 104 件(標準ライブラリのみ)
python tools/audit.py                  通信していないことの実測
python tools/check_compat.py           Python 3.8 で動くかの静的確認

3 つ目について。社内の Python のバージョンは選べないので、
下限を宣言したら守り続ける必要があります。
新しい構文を 1 か所書くだけで持ち込み先で動かなくなり、しかも手元では気づけません。

構文チェックだけでは足りないのがポイントで、
def f(x: list[str]) は 3.8 でも構文としては通り、
注釈が評価される瞬間に TypeError になります。
なので「実行時に評価される型が新しい書き方でないか」も併せて見ています。
(全ファイルで from __future__ import annotations を入れて注釈を文字列化し、
実行時に評価される型だけ typing.Union を使う、という方針です)

制限

  • 隣り合った変更は衝突になる(前述。git merge-file と同じ挙動)
  • 3 者で文字コードが食い違う場合は自分側を優先し、レポートに警告を出す
  • 読み取り専用のファイルや、他プロセスが開いているファイル(Excel など)には
    書き込めない。終了コード 2 で止まる。--in-place が途中で止まった場合は
    .likegit/backups/ から元に戻せる
  • スナップショットはソースの完全な複製なので、プロジェクトごと zip して渡すと
    .likegit/ も同行する。LIKEGIT_DIR で置き場所を外に移せる
  • ファイルの移動・改名は追跡しない(削除 + 追加として扱う)
  • シンボリックリンクは走査時に読み飛ばす
  • 履歴管理・ブランチ・リモート同期はしない

最後に、身も蓋もないことを書いておきます。
git が使えるなら git を使ってください。 これは git の代わりではありません。
「使えない事情がある間、被害を減らす」ための道具です。

全コード

以下を丸ごとコピーして likegit_bundle.py として保存し、python likegit_bundle.py で
展開してください。--verify でコピペが壊れていないか確認できます。

ライセンスは MIT です。

likegit_bundle.py
"""likegit — 1 ファイルにまとめた配布用バンドル (自動生成)。

git が使えない環境で、メンバーから受け取ったコードを安全に統合するツール。
外部パッケージには一切依存しない。必要なのは Python 3.8 以上だけ。

■ 使い方

    python likegit_bundle.py              ./likegit_project に展開する
    python likegit_bundle.py --to ./tools/likegit    展開先を指定する
    python likegit_bundle.py --list       中身の一覧だけ見る
    python likegit_bundle.py --verify     コピペが壊れていないか確認する

展開したあと:

    cd likegit_project
    python -m unittest discover -s tests   全テストを走らせる
    python tools/audit.py                  通信していないことを実測する
    python -m likegit --help               使い方を見る

■ このファイルについて

各ファイルの SHA-256 を一緒に持っている。ブラウザからのコピペで
行が欠けたり空白が変わったりすれば --verify で分かる。
中身は素のソースそのままなので、展開する前に目で読める。
"""

from __future__ import annotations

import hashlib
import sys
from pathlib import Path

MARKER = "#@@ likegit-bundle @@"
DEFAULT_TARGET = "likegit_project"


def parse_payload():
    """PAYLOAD を (相対パス, 内容, 記録されたハッシュ) の列に戻す。"""
    files = []
    rel = digest = None
    lines = []
    for line in PAYLOAD.split("\n"):
        if line.startswith(MARKER):
            if rel is not None:
                files.append((rel, "\n".join(lines), digest))
            _, _, rest = line.partition(MARKER)
            rel, _, digest = (part.strip() for part in rest.partition("@@"))
            lines = []
        else:
            lines.append(line)
    if rel is not None:
        files.append((rel, "\n".join(lines), digest))
    return files


def verify(files):
    """記録されたハッシュと実際の内容を突き合わせる。"""
    broken = []
    for rel, text, digest in files:
        actual = hashlib.sha256(text.encode("utf-8")).hexdigest()
        if actual != digest:
            broken.append((rel, digest, actual))
    return broken


def main(argv):
    args = list(argv)
    target = Path(DEFAULT_TARGET)
    if "--to" in args:
        index = args.index("--to")
        if index + 1 >= len(args):
            print("エラー: --to のあとに展開先を書いてください", file=sys.stderr)
            return 2
        target = Path(args[index + 1])
        del args[index:index + 2]

    files = parse_payload()
    broken = verify(files)

    if "--list" in args:
        for rel, text, _ in files:
            print(f"  {rel:<28} {len(text.splitlines()):>5} 行")
        print(f"\n  合計 {len(files)} ファイル")
        return 0

    if broken:
        print("!! このバンドルは壊れています。コピペで内容が変わった可能性があります。",
              file=sys.stderr)
        for rel, expected, actual in broken:
            print(f"   {rel}\n     記録: {expected}\n     実際: {actual}", file=sys.stderr)
        print("\n   元のページからもう一度コピーし直してください。", file=sys.stderr)
        return 2

    if "--verify" in args:
        print(f"OK: {len(files)} ファイルすべてハッシュが一致しました。")
        return 0

    # 展開先が空でなければ拒否する。likegit 本体と同じ方針。
    if target.exists() and any(target.iterdir()) and "--force" not in args:
        print(f"エラー: 展開先が空ではありません: {target.resolve()}", file=sys.stderr)
        print("  別の場所を --to で指定するか、上書きしてよければ --force を付けてください。",
              file=sys.stderr)
        return 2

    for rel, text, _ in files:
        path = target / rel
        path.parent.mkdir(parents=True, exist_ok=True)
        path.write_text(text, encoding="utf-8")

    print(f"{len(files)} ファイルを展開しました: {target.resolve()}")
    print()
    print("  動作確認:")
    print(f"    cd {target}")
    print("    python -m unittest discover -s tests")
    print("    python tools/audit.py")
    print("    python -m likegit --help")
    return 0


PAYLOAD = r'''
#@@ likegit-bundle @@ README.md @@ 2b922e39e94173bd7f27473102988666aa851c8cb675976a7c3521b708f8a24f
# likegit

git が使えない環境で、メンバーから受け取ったコードを自分の作業ツリーへ安全に統合する。

外部パッケージに依存しない。必要なのは **Python 3.8 以上だけ**。
`pip install` が通らない社内環境で動くことを前提に設計している。

設計の理由は [DESIGN.md](DESIGN.md) に、ここには使い方だけを書く。

---

## 何を解決するか

フォルダを zip で渡し合っていると、返ってきたコードを取り込む時点で必ず困る。

- どちらが変更した行なのか分からない
- 目視でマージすると、片方の修正を黙って捨ててしまう
- CRLF と Shift_JIS が混ざり、1 行も変えていないのに全ファイルが差分になる

likegit は **渡す前の状態 (base) を控えておく** ことでこれを解く。
base があれば「どちらが変えたか」が一意に決まり、実務では 8〜9 割が自動で片付く。
残るのは、両者が同じ行を別々に変えた箇所だけになる。

---

## 使い方

### 1. 渡す前に控えを取る

**これを忘れると精度が落ちる。** 一番大事な操作。

```
python -m likegit snapshot ./src -m "Aさんに渡す前"
```

```
退避しました: 20260825-103000_Aさんに渡す前
  元       : C:\work\myproject\src
  保存先   : C:\work\myproject\.likegit\snapshots\20260825-103000_Aさんに渡す前
  ファイル : 42 件

統合時は  --base 20260825-103000_Aさんに渡す前  と指定してください。
```

控えは `.likegit/snapshots/` にただのファイルコピーとして置かれる。
独自形式は使っていないので、エクスプローラで開いて中身を確認できる。

### 2. それぞれ編集する

自分は `./src` を、相手は渡したコピーを編集する。

### 3. 受け取って統合する

```
python -m likegit merge --base 20260825-103000_Aさんに渡す前 ^
                        --mine ./src --theirs ./from_A --out ./merged
```

```
likegit merge レポート
  base   : 20260825-103000_Aさんに渡す前
  mine   : C:\work\myproject\src
  theirs : C:\work\myproject\from_A
  out    : C:\work\myproject\merged
  日時   : 2026-08-25T14:22:10

[衝突] 2 件 -- 手で直してください
  app.py    衝突            1 箇所 (行 12)
  book.xlsx 衝突(バイナリ)  1 箇所
              - バイナリのため自動統合不可。相手の版を book.THEIRS.xlsx に置きました

[集計]
  変更なし        36
  自動マージ       3
  相手の版を採用   1
  相手が追加       1
  衝突             1
  衝突(バイナリ)   1
  合計            43

結果: 衝突 2 ファイル / 2 箇所。C:\work\myproject\merged を開いて <<<<<<< を解決してください。
```

`--mine` と `--theirs` は**絶対に書き換えない**。結果は必ず第 3 の場所に出る。

### 4. 衝突を直す

`merged/` の中で `<<<<<<<` を含むファイルを開く。

```python
def calc(x):
<<<<<<< MINE
    return x * 3
=======
    return x * 4
>>>>>>> THEIRS
```

どちらを採るか決めて、マーカー 3 行ごと消す。

### 5. 反映する

`merged/` を `./src` に上書きする。次に渡すときは、また手順 1 から。

---

## よく使うオプション

| オプション | 効果 |
|---|---|
| `--dry-run` | 1 バイトも書かずに結果だけ見る。**初めて使うときはこれから** |
| `--in-place` | `merged/` を経由せず `./src` に直接書き戻す。事前に自動でバックアップを取る |
| `--diff3` | 衝突マーカーに base の内容も入れる。どちらが何を変えたか分かる |
| `--prefer mine` / `--prefer theirs` | 衝突を人手ではなく指定側の内容で自動的に決着させる |
| `--label-mine 自分 --label-theirs Aさん` | マーカーの見出しを分かりやすくする |
| `-v` | ファイルごとの判定を全部出す |
| `--force` | `--out` が空でなくても上書きする |

`--base` を省くと 2-way マージになり、**差分がすべて衝突になる**。
手順 1 を忘れたときの最後の手段であって、通常は使わない。

### 控えの一覧

```
python -m likegit snapshots            退避した base の一覧
python -m likegit snapshots --backups  --in-place で取られたバックアップの一覧
```

---

## 除外設定

`.likegit/`, `.git/`, `__pycache__/`, `node_modules/`, `*.pyc`, `~$*` (Excel のロックファイル)
などは最初から除外される。

追加したいものは、対象フォルダ直下に `.likegitignore` を置く。

```
*.log
build/
temp/
```

書式は `.gitignore` の簡略版 (`fnmatch` ベース、否定の `!` は非対応)。

---

## 安全のために決めていること

git が無い環境では取り消しが効かないので、ここは厚くしてある。

1. `--mine` と `--theirs` は書き換えない。出力は必ず第 3 の場所
2. `--out` が空でなければ拒否 (`--force` で上書き許可)
3. `--out` が `--mine` / `--theirs` / base の中を指していたら拒否
4. `--mine` / `--theirs` / base が入れ子になっていたら拒否
5. `--in-place` は必ず先に `.likegit/backups/` へ退避してから書き込む
6. `--dry-run` は書き込みゼロ。レポートも残さない
7. 元ファイルに `<<<<<<<` があれば警告する
8. 書き込みは全ファイルの判定を終えてから始める (途中で止まって半端に壊れにくくする)
9. **1 件も退避できなかった `snapshot` は成功にしない**。0 件の base は base として
   機能しないので、その場で止める(黙って通すと、統合時に全ファイルが衝突になって
   初めて気づくことになる)

**バイナリファイル** (Excel, 画像など) は行マージができないので、
両者が別々に変更した場合は自分の版を残し、相手の版を `book.THEIRS.xlsx` として
隣に置く。レポートにも必ず出る。

**削除と変更がぶつかった場合** はファイル内にマーカーを書けないため、
変更が入っている側を残してレポートで知らせる。

---

## 終了コード

バッチファイルから分岐できるようにしてある。

| コード | 意味 |
|---|---|
| 0 | 衝突なし。そのまま反映してよい |
| 1 | 衝突あり。人間の解決が必要 |
| 2 | エラー (引数不正・入出力失敗) |

```bat
python -m likegit merge --base %BASE% --mine .\src --theirs .\from_A --out .\merged
if errorlevel 2 echo エラーが起きました & exit /b 1
if errorlevel 1 echo 衝突あり。merged\ を確認してください & exit /b 1
echo 衝突なし
```

---

## 情報が外に出ないことの確認

業務コードを通すツールなので、**通信を一切しない**ことを実測できるようにしてある。

```
python tools/audit.py
```

Python の監査フック (`sys.addaudithook`) で、実行中に発生する
通信・プロセス起動・ファイル読み書きのイベントを **全部** 捕捉する。
`socket` を経由せず `ctypes` で叩くような細工もここに現れる。

```
likegit 監査結果   (Python の監査フックで全イベントを捕捉)
==========================================================================
  通信          socket/urllib/http/smtp/asyncio ...
      likegit 由来:   0 件  [OK]
  プロセス起動  subprocess/os.system/ctypes/winreg
      likegit 由来:   0 件  [OK]
  動的コード実行 文字列の exec/eval, pickle.loads
      likegit 由来:   0 件  [OK]
--------------------------------------------------------------------------
  likegit が書き込んだ先: 指定パス内 16 件 / 指定パス外 0 件  [OK]

判定: 完全ローカル。通信なし・指定パス外への書き込みなし。
```

裏付けとなる事実:

- インポートしている標準ライブラリは
  `argparse` `codecs` `dataclasses` `datetime` `difflib` `fnmatch`
  `json` `os` `pathlib` `re` `shutil` `sys` `typing` のみ。
  **ネットワークを扱えるモジュールが 1 つも入っていない**
- 外部パッケージ依存はゼロ ([requirements.txt](requirements.txt) は空)
- 書き込むのは「引数で指定された場所」と「スナップショット置き場」だけ
- 環境変数は `LIKEGIT_DIR` を**読む**だけ。書かない、送らない
- テレメトリ、自動更新、クラッシュレポートの類は一切ない

### 1 つだけ注意: 退避先を相手に渡さないこと

`.likegit/snapshots/*/tree/` には **ソースコードの完全な複製** が入る
(それがスナップショットなので当然だが)。すべてローカルに留まる。

ただし **プロジェクトフォルダごと zip して相手に渡すと `.likegit/` も同行し、
過去の全スナップショットが相手に渡る。**

既定では `.likegit` はコマンドを実行したフォルダの直下にできるので、
渡すのが `src/` だけなら問題ない。プロジェクトごと渡す運用なら、
置き場所を外に移す。

```
set LIKEGIT_DIR=D:\likegit-store
```

なお merge の出力先に `.likegit` が混入することはない(除外済み)。

---

## 検証

```
python -m unittest discover -s tests   テスト 104 件 (標準ライブラリのみ)
python tools/audit.py                  通信していないことの実測
python tools/check_compat.py           Python 3.8 で動くかの静的確認
```

CI が無い前提なので、どれも 1 コマンドで完結し、終了コードで判定できる。

---

## ダウンロードできない環境へ持ち込む

社内 PC でファイルのダウンロードが禁じられていて、ブラウザだけが通る場合。
プロジェクト全体を 1 ファイルにまとめられる。

配る側:

```
python tools/bundle.py        ->  likegit_bundle.py (1 ファイル)
```

受け取る側は、その中身をテキストエディタに貼って `likegit_bundle.py` として保存し:

```
python likegit_bundle.py --verify   コピペで壊れていないか確認する
python likegit_bundle.py            ./likegit_project に展開する
```

各ファイルの SHA-256 を一緒に埋め込んであるので、
**コピペで行が欠けたり空白が変わったりすれば `--verify` で分かる**。
中身は base64 などにせず素のソースのまま入れてあるので、展開する前に目で読める。

> 社外のサイトにコードを置く場合は、それが会社の規程に反しないかを先に確認すること。
> このツール自体は業務情報を含まない汎用コードだが、公開の可否を判断するのは会社。

---

## ライセンス

MIT License ([LICENSE](LICENSE))。改変も再配布も自由。

---

## 制限

- **隣り合った変更は衝突になる。** 双方の変更の間に無変更の行が 1 行も無い場合、
  同期点が取れず衝突として報告される。これは古典的な diff3 の性質で、
  `git merge-file` も同じ入力で同じ衝突を出す。git と挙動を揃えることを優先している
- 読み取り専用のファイルや、他プロセスが開いているファイル (Excel など) には
  書き込めない。その場合は終了コード 2 で止まる。`--in-place` が途中で止まったときは
  `.likegit/backups/` から元の状態に戻せる
- 3 者で文字コードが食い違う場合は自分側を優先し、レポートに警告を出す
- シンボリックリンクは走査時に読み飛ばす
- ファイルの移動・改名は追跡しない (削除 + 追加として扱う)
- 履歴管理・ブランチ・リモート同期はしない。git の代わりではなく、統合の一点だけを担う

#@@ likegit-bundle @@ DESIGN.md @@ 2eb24d59d3a4aef36746c4359d869a50b14f65153dbd90fedf789ceadaaec796
# likegit 設計書

## 1. 目的

git が使えない環境で、メンバーから受け取ったコード(ファイル or フォルダ)を
自分の作業ツリーへ **安全に** 統合する。

非目標: git の代替(履歴管理・ブランチ・リモート同期)にはしない。
やるのは「統合」の一点だけ。

## 2. 中核となる判断

統合の精度は **共通の出発点(base)を持てるかどうか** で決まる。

| | base なし (2-way) | base あり (3-way) |
|---|---|---|
| 「Aの3行目」と「Bの3行目」が違うとき | どちらが変更側か原理的に判別不能 | base と比較すれば一意に決まる |
| 人間の判断が必要な箇所 | 差分の **全部** | 両者が **同じ行** を別々に変えた箇所のみ |
| 実務での自動化率 | 0% | 概ね 80〜90% |

git が強いのは分散管理ではなく、base を常に持っていること。
本ツールもそこを模倣する。よって構成は 2 層:

- **層1: スナップショット** — メンバーに渡す前の状態を `.likegit/snapshots/` に退避
- **層2: マージエンジン** — 3-way マージ(base が無ければ 2-way にフォールバック)

## 3. 運用フロー

```
[1] 渡す前          likegit snapshot ./src -m "Aさんに渡す前"
                    → .likegit/snapshots/20260824-103000_a-san/

[2] 各自が編集       自分は ./src を、Aさんは受け取ったコピーを編集

[3] 受領・統合      likegit merge --base 20260824-103000_a-san \
                                  --mine ./src --theirs ./from_A --out ./merged

[4] 衝突を解決      merged/ の <<<<<<< を含むファイルをエディタで直す

[5] 反映            merged/ を ./src へ(または最初から --in-place)
```

## 4. モジュール構成

```
likegit/
  __main__.py   python -m likegit の入口
  cli.py        エントリポイント(argparse・終了コード・安全確認)
  snapshot.py   base スナップショットの保存・列挙・解決
  scanner.py    ディレクトリ走査、除外ルール(.likegitignore)
  textio.py     エンコーディング / 改行コードの検出・復元、バイナリ判定
  winpath.py    Windows の 260 文字パス制限の回避(§11)
  diff3.py      マージ中核(3-way / 2-way)。純粋関数、I/O なし
  merger.py     ファイル単位・ツリー単位のマージ手続き
  report.py     結果の集計と整形。Plan だけを入力に取る純粋な層
tests/
  test_diff3.py    マージ中核
  test_textio.py   エンコーディング / 改行コードの往復
  test_merger.py   §7 の分岐表
  test_cli.py      §8 の安全性の原則、§9 の終了コード
  test_winpath.py  260 文字を超えるパスでの読み書き
tools/
  audit.py         通信していないことを実測する(§10)
  check_compat.py  Python 3.8 で動くかを静的に確認する
  bundle.py        全体を 1 ファイルにまとめる(持ち込み用)
```

依存の向きは `cli → merger → {diff3, textio, scanner} → winpath` の一方向。
`winpath` は何にも依存しない末端。
`diff3.py` と `report.py` は I/O を持たないので、単体で検証できる。

対応 Python は **3.8 以上**。持ち込み先のバージョンを選べないため、
型注釈は全ファイルで `from __future__ import annotations` により文字列化し、
実行時に評価される型には `typing.Union` を使う。
下限を宣言しただけでは守れないので `tools/check_compat.py` で機械的に確認する。

依存は標準ライブラリのみ(`difflib`, `os`, `argparse`, ...)。
社内環境で `pip install` が通らない事態を想定。

## 5. マージ中核(diff3.py)

`difflib.SequenceMatcher(autojunk=False)` を base↔mine、base↔theirs の 2 本回し、
**両者が同時に base と一致している区間(同期区間)** を求める。
同期区間の間が「不安定区間」で、ここを 4 通りに判定する。

| 判定 | 条件 | 結果 |
|---|---|---|
| same | mine == theirs | その内容を採用 |
| mine | theirs == base(相手は無変更) | mine を採用 |
| theirs | mine == base(自分は無変更) | theirs を採用 |
| conflict | 両者が別々に変更 | 衝突マーカーを出力 |

> `autojunk=False` は必須。既定の `autojunk` は「頻出要素をノイズ扱い」するため、
> 空行や `}` が多いソースコードで差分が壊滅的に劣化する。

衝突区間は最小化する(mine と theirs の先頭・末尾で一致する行は衝突の外へ出す)。
ただし base 側が食い違う位置では最小化を打ち切り、`--diff3` 出力の整合を守る。

同期区間は「両者が同時に base と一致する」区間なので、双方の変更が
**隣り合っていて間に無変更の行が 1 行も無い** 場合、同期点が取れず 1 つの
不安定区間にまとまり衝突になる。これは古典的 diff3 の性質で、
`git merge-file` も同じ入力で同じ衝突を出す(検証済み)。
自動化率を上げるための小細工はしない。git と挙動が食い違う方が事故になる。

出力形式:

```
<<<<<<< MINE
    return x * 2
=======
    return x * 3
>>>>>>> THEIRS
```

## 6. エンコーディングと改行コード(textio.py)

日本語 Windows 環境で最も高頻度の事故は
**「1 行も変えていないのにファイル全体が差分になる」** で、原因は次の 2 つ:

- CRLF / LF の混在
- UTF-8 / CP932(Shift_JIS)の混在

対策として、比較と保存を明確に分離する。

- **比較時**: 改行コードを剥がした「行の配列」に正規化 → 差分から消える
- **保存時**: 元ファイルの改行コード・エンコーディング・BOM・末尾改行の有無を復元

エンコーディング判定は、まず BOM の有無を直接見る。BOM があれば `utf-8-sig`、
無ければ `utf-8 → cp932 → euc_jp` の順に試行する。
UTF-8 として妥当なバイト列が CP932 としても妥当なことは稀なので、この順序が安全側。

> `utf-8-sig` を試行リストの先頭に並べてはいけない。この codec は BOM の無い
> バイト列も問題なく復号するため、候補にすると BOM の無いファイルまで
> `utf-8-sig` と判定され、保存時に BOM を付け足してしまう。
> 「1 行も変えていないのに全体が差分になる」事故そのものを、このツール自身が
> 起こすことになる。

UTF-16 / UTF-32 は NUL バイトを含むためバイナリ判定に落ち、行マージの対象外になる。

3 者でエンコーディングが食い違う場合は mine を優先し、レポートに警告を出す。

## 7. ツリー単位の判定(merger.py)

base / mine / theirs それぞれの相対パス集合の和を取り、存在有無で分岐する。

| base | mine | theirs | 動作 |
|:---:|:---:|:---:|---|
| − | − | ✓ | theirs を追加 |
| − | ✓ | − | mine を維持 |
| − | ✓ | ✓ | 両者が新規作成 → 内容一致なら採用、違えば 2-way マージ |
| ✓ | ✓ | ✓ | 3-way マージ |
| ✓ | − | ✓ | mine が削除。theirs が無変更なら削除、変更済みなら **削除/変更の衝突** |
| ✓ | ✓ | − | 上の対称形 |
| ✓ | − | − | 両者が削除 → 消す |

削除/変更の衝突はファイル内にマーカーを書けないため、
**変更が入っている側を残し**、レポートで明示する。

バイナリファイルは行マージが意味を持たないため:
一方だけ変更 → その版を採用 / 両方が別内容 → mine を採用し、
`foo.THEIRS.xlsx` という退避ファイルを隣に置いてレポートに記録する。

## 8. 安全性の原則

git が無い=取り消せないため、ここは厚くする。

1. **入力の 2 つ(mine / theirs)を絶対に書き換えない。** 出力は第 3 のディレクトリ
2. `--out` の指定先が空でなければ拒否(`--force` で上書き許可)
3. `--out` が mine / theirs / base の内側を指していたら拒否。書きながら読む形になり
   原則 1 が崩れるため。base を含めるのは、そこが唯一の復旧手段だから
4. mine / theirs / base が互いに入れ子なら拒否。走査結果が混ざり、結果が意味を失う
   (ただし既定の store は `./.likegit` にあり `--mine .` で入れ子になるが、
   scanner が `.likegit/` を除外するため実害が無く、これは許す)
5. `--in-place` は自動で mine のバックアップを `.likegit/backups/` に取ってから実行
6. `--dry-run` で書き込みゼロのまま結果サマリだけ確認可能。レポートも残さない
7. 元ファイルに `<<<<<<<` が含まれていたら警告(マーカーの誤認を防ぐ)
8. 書き込みは計画(`plan_*`)を全部作り終えてから行う。途中で失敗して
   半分だけ書き換わった状態を作りにくくする
9. 空ディレクトリの掃除は、自分が消したファイルの親だけを上へ辿る。
   ツリー全体を走査して空フォルダを消すと、元から意図的に空だった
   置き場所(`logs/` など)まで巻き込む
10. **1 件も退避できなかった `snapshot` は成功にしない**(終了コード 2)。
    0 件の base は base として機能せず、それを黙って通すと「控えを取ったつもり」で
    統合に進み、全ファイルが衝突になって初めて気づく。このツールの前提そのものが
    崩れる形の失敗なので、その場で止める。
    空の base を `--base` に指定した `merge` も、レポートで警告する

## 9. 終了コード

| コード | 意味 | 用途 |
|---|---|---|
| 0 | 衝突なし | そのまま反映してよい |
| 1 | 衝突あり | 人間の解決が必要 |
| 2 | エラー | 引数不正・入出力失敗 |

バッチ処理から `if errorlevel 1` で分岐できるようにするため。

## 10. 外部と通信しないこと

業務コードを通すツールなので、「情報が外に出ない」は設計上の要件として扱う。

- 依存は標準ライブラリのみ。しかも **ネットワークを扱えるモジュールを 1 つも
  import していない**(`argparse` `codecs` `dataclasses` `datetime` `difflib`
  `fnmatch` `json` `os` `pathlib` `re` `shutil` `sys` `typing` のみ)
- 書き込むのは引数で指定された場所とスナップショット置き場だけ
- 環境変数は `LIKEGIT_DIR` を読むのみ。書かない、送らない
- テレメトリ・自動更新・クラッシュレポートを持たない

ソースを読めば分かることだが、持ち込みの可否を判断するのは書いた本人ではないので、
実測して提出できる形にする。`tools/audit.py` が `sys.addaudithook` で実行中の
通信・プロセス起動・ファイル読み書きを全件捕捉し、終了コードで判定する。
`socket` を経由せず `ctypes` で叩くような細工もこのフックには現れる。

なお **退避したスナップショットはソースの完全な複製** である(それがスナップショット
の定義なので当然だが)。ローカルに留まるとはいえ、プロジェクトごと zip して相手に
渡すと `.likegit/` も同行し、過去の全スナップショットが相手に渡る。
`LIKEGIT_DIR` で置き場所をプロジェクトの外に移せるようにしてあるのはこのため。

## 11. Windows の 260 文字パス制限

退避先は元のパスに `.likegit/snapshots/<名前>/tree/` が付くぶん長くなる。
実測で **44 文字(メッセージ無し)〜77 文字(メッセージ 40 文字)** 伸びる。
元ファイルが作れていても退避先が 260 文字を超える、ということが階層の深い
プロジェクトでは普通に起きる。

制限を外すレジストリ設定(`LongPathsEnabled`)は管理者権限が要り、
社内 PC ではまず変更できない。そこで `\\?\` 接頭辞を使う。
これは **そのパス 1 つだけ制限を外す** もので、権限も設定変更も要らない。

方針は「**I/O の直前だけで接頭辞を付け、保持・表示するパスは接頭辞なしのまま**」。
`\\?\C:\...` がレポートやエラーメッセージに現れると読み手を混乱させるため。

| | |
|---|---|
| 接頭辞を付ける場所 | `scanner.scan` の走査、`textio.load` の読み、`snapshot.create` のコピー、`merger.apply` の書き込み・削除 |
| 付けない場所 | `Outcome.writes[].src`、レポート、エラーメッセージ |

`\\?\` 付きのパスは OS 側で正規化されないまま渡るため、`..` や `/` を
含んでいてはいけない。`os.path.abspath` でそれを担保する。

> 実装中に 2 つ誤った前提を立てたので記録しておく。どちらも
> 「pathlib が接頭辞を壊す」「`os.makedirs` が使えない」というもので、
> **どちらも成り立たなかった**。pathlib は接頭辞を保持し、`mkdir(parents=True)`・
> `write_bytes`・`stat`・`unlink`・`shutil.copy2`・`os.walk` はいずれも
> そのまま動く(`tests/test_winpath.py` で 300 文字超のパスに対して検証済み)。
> 誤った観察に基づいて複雑な代替実装を書きかけたので、確認してから設計すること。

#@@ likegit-bundle @@ LICENSE @@ c9683a4984cbd840a672e460a77ce8ada0ac16a9fd4c472e7d352d8689788b19
MIT License

Copyright (c) 2026 ChocoMonja

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

#@@ likegit-bundle @@ requirements.txt @@ 6b9ccbe94319bb7e3e9b84478f953f0161057debd52bdb72f43136b8063454c0
# likegit は外部パッケージに一切依存しない。
#
# このファイルが空なのは書き忘れではなく、要件そのもの。
# pip install が通らない社内環境で動くことを前提に設計しているため、
# ここに何かを足すときは「その環境に配れるか」を先に確認すること。
#
#   pip install -r requirements.txt   -> 何も入らない (正常)
#
# 使用している標準ライブラリ:
#   argparse  codecs  dataclasses  datetime  difflib  fnmatch
#   json      os      pathlib      re        shutil   sys      typing
#
# 必要なもの: Python 3.8 以上のみ
#   確認:  python --version
#
#   3.8 は 2019 年のリリース。社内の固定 Python が古くても動くよう、
#   新しい構文はあえて使っていない:
#     - 型注釈は全ファイルで `from __future__ import annotations` により
#       文字列化しているので、`X | None` を書いても評価されない
#     - 実行時に評価される型は typing.Union / typing.Sequence を使う
#       (diff3.py の Region がこれに当たる)
#   検証方法:  python tools/check_compat.py
#
# 検証・開発時も追加不要:
#   python -m unittest discover -s tests   テスト (標準ライブラリのみ)
#   python tools/audit.py                  通信していないことの実測

#@@ likegit-bundle @@ likegit/__init__.py @@ 2cc7a1c518238194fff837240387d17054bc8317788c93ede3f3f4d38e0119d5
"""likegit — git を使わずにコードを統合するための最小ツール。

設計の詳細は DESIGN.md を参照。
"""

__version__ = "0.1.0"

#@@ likegit-bundle @@ likegit/__main__.py @@ 6959e6de3d263b6b44bda12c0ac7234364470734e0a549a72f0b9fa3180c4a4f
"""`python -m likegit` の入口。"""

import sys

from .cli import main

sys.exit(main())

#@@ likegit-bundle @@ likegit/cli.py @@ e7a011e3f42f82ba58ace3d67fcfbac6f82a1936e4e3a665206bddbe12ab6dde
"""エントリポイント。引数の解釈・安全確認・終了コードだけを持つ。

実際の処理は snapshot / merger / report に委ね、ここには判断を置かない。
唯一ここが責任を持つのは DESIGN.md §8 の安全性の原則で、
「取り消せない書き込みを、確認なしに行わない」ことを門番として保証する。

終了コード: 0=衝突なし / 1=衝突あり / 2=エラー
"""

from __future__ import annotations

import argparse
import shutil
import sys
from pathlib import Path

from . import __version__, merger, report, snapshot

EXIT_OK = 0
EXIT_CONFLICT = 1
EXIT_ERROR = 2


class UserError(Exception):
    """利用者の操作で直せる失敗。トレースバックを出さずに終了コード 2 にする。"""


# --------------------------------------------------------------------------
# 出力
# --------------------------------------------------------------------------


def _prepare_streams() -> None:
    """コンソールが CP932 でも日本語の出力で落ちないようにする。

    レポートに含まれるファイル名やパスは環境由来で、コンソールの
    コードページで表現できない文字を含みうる。統合そのものは終わって
    いるのに UnicodeEncodeError で失敗扱いになるのを避ける。
    """
    for stream in (sys.stdout, sys.stderr):
        reconfigure = getattr(stream, "reconfigure", None)
        if reconfigure is not None:
            try:
                reconfigure(errors="backslashreplace")
            except (ValueError, OSError):
                pass


def _err(message: str) -> None:
    print(f"エラー: {message}", file=sys.stderr)


# --------------------------------------------------------------------------
# 引数
# --------------------------------------------------------------------------


def build_parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(
        prog="likegit",
        description="git が使えない環境で、受け取ったコードを安全に統合する。",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog=(
            "使い方の流れ:\n"
            "  1. 渡す前   likegit snapshot ./src -m \"Aさんに渡す前\"\n"
            "  2. 受領後   likegit merge --base 20260824-103000_A --mine ./src \\\n"
            "                            --theirs ./from_A --out ./merged\n"
            "  3. 解決     merged/ の <<<<<<< を直して ./src へ反映\n"
        ),
    )
    parser.add_argument("--version", action="version", version=f"likegit {__version__}")
    subparsers = parser.add_subparsers(dest="command", metavar="コマンド")

    store_help = "スナップショット置き場 (既定: ./.likegit、環境変数 LIKEGIT_DIR)"

    # -- snapshot ----------------------------------------------------------
    snap = subparsers.add_parser(
        "snapshot",
        help="現在の状態を base として退避する",
        description="メンバーに渡す前の状態を退避し、あとで --base に使えるようにする。",
    )
    snap.add_argument("source", help="退避するディレクトリ (またはファイル)")
    snap.add_argument("-m", "--message", default="", help="用途のメモ。名前の一部になる")
    snap.add_argument("--name", help="スナップショット名を自分で決める")
    snap.add_argument("--store", help=store_help)
    snap.set_defaults(func=cmd_snapshot)

    # -- snapshots ---------------------------------------------------------
    snaps = subparsers.add_parser(
        "snapshots", help="退避済みスナップショットの一覧", description="--base に指定できる名前を並べる。"
    )
    snaps.add_argument("--backups", action="store_true", help="--in-place のバックアップを見る")
    snaps.add_argument("--store", help=store_help)
    snaps.set_defaults(func=cmd_snapshots)

    # -- merge -------------------------------------------------------------
    merge = subparsers.add_parser(
        "merge",
        help="自分の版と相手の版を統合する",
        description=(
            "mine と theirs を統合する。--base があれば 3-way、なければ 2-way。"
            "入力の 2 つは絶対に書き換えない。"
        ),
    )
    merge.add_argument("--mine", required=True, help="自分の作業ツリー (書き換えない)")
    merge.add_argument("--theirs", required=True, help="受け取った版 (書き換えない)")
    merge.add_argument(
        "--base", help="共通の出発点。スナップショット名、またはディレクトリ"
    )
    merge.add_argument("--out", help="出力先。空でなければ拒否 (--force で上書き)")
    merge.add_argument(
        "--in-place",
        action="store_true",
        help="mine に直接書き戻す。事前に自動でバックアップを取る",
    )
    merge.add_argument(
        "--dry-run", action="store_true", help="書き込まずに結果だけ見る"
    )
    merge.add_argument("--force", action="store_true", help="--out が空でなくても上書きする")
    merge.add_argument(
        "--diff3", action="store_true", help="衝突マーカーに base の内容も入れる"
    )
    merge.add_argument(
        "--prefer",
        choices=("mine", "theirs"),
        help="衝突を人手ではなく指定側の内容で自動的に決着させる",
    )
    merge.add_argument("--label-mine", default="MINE", help="衝突マーカーの自分側の見出し")
    merge.add_argument("--label-theirs", default="THEIRS", help="同じく相手側の見出し")
    merge.add_argument("--label-base", default="BASE", help="--diff3 のときの base の見出し")
    merge.add_argument("-v", "--verbose", action="store_true", help="全ファイルの判定を出す")
    merge.add_argument("--all", action="store_true", help="-v で変更なしのファイルも出す")
    merge.add_argument("--report", help="レポートの保存先を指定する")
    merge.add_argument("--no-report", action="store_true", help="レポートを保存しない")
    merge.add_argument("--store", help=store_help)
    merge.set_defaults(func=cmd_merge)

    return parser


# --------------------------------------------------------------------------
# snapshot / snapshots
# --------------------------------------------------------------------------


def cmd_snapshot(args: argparse.Namespace) -> int:
    source = Path(args.source).expanduser()
    if not source.exists():
        raise UserError(f"見つかりません: {source}")

    store = snapshot.store_root(args.store)
    try:
        snap = snapshot.create(source, store, message=args.message, name=args.name)
    except FileExistsError as exc:
        raise UserError(str(exc)) from exc

    print(f"退避しました: {snap.name}")
    print(f"  元       : {snap.source}")
    print(f"  保存先   : {snap.path}")
    print(f"  ファイル : {snap.file_count} 件")

    if snap.file_count == 0:
        # 0 件の base は base として役に立たない。それを黙って成功扱いにすると、
        # 「控えを取ったつもり」で統合に進み、全ファイルが衝突になって初めて
        # 気づくことになる。このツールの前提が崩れる形の失敗なので、ここで止める。
        #
        # 中身の無い控えを残すと、あとで --base の候補として選べてしまい、
        # いま塞いだ罠がそのまま残る。作りかけを片付けてから終わる。
        shutil.rmtree(snap.path, ignore_errors=True)
        print()
        _err(
            f"1 件も退避できていません: {source}\n"
            f"  パスが違うか、中身が空か、除外設定 (.likegitignore) が\n"
            f"  全部を弾いている可能性があります。\n"
            f"  中身の無い控えを --base に指定しても 3-way にはならず、\n"
            f"  差分がすべて衝突になるため、この控えは残していません。"
        )
        return EXIT_ERROR

    print()
    print(f"統合時は  --base {snap.name}  と指定してください。")
    return EXIT_OK


def cmd_snapshots(args: argparse.Namespace) -> int:
    store = snapshot.store_root(args.store)
    kind = snapshot.BACKUPS if args.backups else snapshot.SNAPSHOTS
    entries = snapshot.listing(store, kind)

    if not entries:
        label = "バックアップ" if args.backups else "スナップショット"
        print(f"{label}はまだありません。({store / kind})")
        return EXIT_OK

    # 日本語のメモが名前に入るので、文字数ではなく表示幅で揃える。
    width = max(report.display_width(s.name) for s in entries)
    for snap in entries:
        line = f"{report.pad(snap.name, width)}  {snap.created_at}  {snap.file_count:>5} 件"
        if snap.message:
            line += f"  {snap.message}"
        print(line)
    return EXIT_OK


# --------------------------------------------------------------------------
# merge
# --------------------------------------------------------------------------


def _resolve_inputs(args: argparse.Namespace) -> tuple[Path, Path]:
    mine = Path(args.mine).expanduser()
    theirs = Path(args.theirs).expanduser()

    for label, path in (("--mine", mine), ("--theirs", theirs)):
        if not path.exists():
            raise UserError(f"{label} が見つかりません: {path}")

    if mine.is_dir() != theirs.is_dir():
        raise UserError(
            "--mine と --theirs は両方ディレクトリか、両方ファイルにしてください "
            f"(--mine={'dir' if mine.is_dir() else 'file'} "
            f"--theirs={'dir' if theirs.is_dir() else 'file'})"
        )
    return mine.resolve(), theirs.resolve()


def _is_within(child: Path, parent: Path) -> bool:
    try:
        child.resolve().relative_to(parent.resolve())
    except ValueError:
        return False
    return True


def _check_inputs_are_distinct(mine: Path, theirs: Path, base: Path | None) -> None:
    """3 つの入力が別物であることを確かめる。

    入れ子だと、たとえば mine の走査結果に theirs のファイルが丸ごと混ざり、
    レポートも結果も意味を失う。--in-place ならその状態で書き込みまで進む。
    """
    named = [("--mine", mine), ("--theirs", theirs)]
    if base is not None and not _is_managed_snapshot(base):
        # 既定の store は ./.likegit なので、--mine . だと base が mine の中に入る。
        # scanner が .likegit/ を除外するため実害が無く、これは正当な使い方。
        named.append(("base", base))

    for i, (label_a, a) in enumerate(named):
        for label_b, b in named[i + 1 :]:
            if a == b:
                raise UserError(f"{label_a} と {label_b} が同じ場所です: {a}")
            if _is_within(a, b) or _is_within(b, a):
                raise UserError(
                    f"{label_a} と {label_b} が入れ子になっています。\n"
                    f"  {a}\n  {b}\n"
                    f"  互いに独立した場所を指定してください。"
                )


def _is_managed_snapshot(path: Path) -> bool:
    """likegit が管理する store の中のパスか。"""
    return snapshot.STORE_DIRNAME in path.parts


def _check_out(
    out: Path, mine: Path, theirs: Path, base: Path | None, is_dir: bool, force: bool
) -> None:
    """出力先が入力を壊さないこと、既存の中身を黙って潰さないことを確かめる。"""
    protected = [("--mine", mine), ("--theirs", theirs)]
    if base is not None:
        # base は唯一の復旧手段。ここを潰されると 3-way に戻れなくなる。
        protected.append(("base", base))

    for label, source in protected:
        if out == source or _is_within(out, source):
            raise UserError(
                f"--out が {label} の中を指しています: {out}\n"
                f"  入力は書き換えない方針のため、別の場所を指定してください。"
            )

    if not out.exists():
        return

    if is_dir:
        if not out.is_dir():
            raise UserError(f"--out がディレクトリではありません: {out}")
        if any(out.iterdir()) and not force:
            raise UserError(
                f"--out が空ではありません: {out}\n"
                f"  中身を上書きしてよければ --force を付けてください。"
            )
    else:
        if out.is_dir():
            raise UserError(
                f"--out がディレクトリです。ファイル単位のマージではファイル名を指定してください: {out}"
            )
        if not force:
            raise UserError(
                f"--out が既にあります: {out}\n  上書きしてよければ --force を付けてください。"
            )


def _make_plan(
    args: argparse.Namespace, mine: Path, theirs: Path, base: Path | None
) -> tuple[merger.Plan, merger.Options]:
    options = merger.Options(
        labels=merger.Labels(
            mine=args.label_mine, theirs=args.label_theirs, base=args.label_base
        ),
        show_base=args.diff3,
        prefer=args.prefer,
    )
    if mine.is_dir():
        plan = merger.plan_tree(base, mine, theirs, options)
    else:
        rel = Path(args.out).name if (args.out and not args.in_place) else mine.name
        plan = merger.plan_files(base, mine, theirs, options, rel=rel)
    return plan, options


def cmd_merge(args: argparse.Namespace) -> int:
    if args.out and args.in_place:
        raise UserError("--out と --in-place は同時に使えません。")
    if not args.out and not args.in_place and not args.dry_run:
        raise UserError(
            "出力先がありません。--out DIR か --in-place、"
            "または結果だけ見る --dry-run を指定してください。"
        )

    mine, theirs = _resolve_inputs(args)
    store = snapshot.store_root(args.store)

    base: Path | None = None
    if args.base:
        try:
            base = snapshot.resolve_base(args.base, store)
        except FileNotFoundError as exc:
            raise UserError(str(exc)) from exc
        # base の種類は mine / theirs と揃っていなければならない。
        if mine.is_dir() and not base.is_dir():
            raise UserError(
                f"--mine がディレクトリなので base もディレクトリが必要です: {base}"
            )
        if not mine.is_dir() and base.is_dir():
            raise UserError(
                f"--mine がファイルなので base もファイルが必要です: {base}\n"
                f"  スナップショットを使う場合は、その中の該当ファイルを直接指定してください。"
            )

    _check_inputs_are_distinct(mine, theirs, base)

    out: Path | None = None
    if args.out:
        out = Path(args.out).expanduser().resolve()
        _check_out(out, mine, theirs, base, mine.is_dir(), args.force)

    plan, _options = _make_plan(args, mine, theirs, base)

    context = report.Context(
        mine=mine,
        theirs=theirs,
        base=base,
        base_spec=args.base,
        out=out,
        in_place=args.in_place,
        dry_run=args.dry_run,
    )

    if not args.dry_run:
        context.backup, context.written = _write(args, plan, mine, out, store)

    text = report.render(
        plan, context, verbose=args.verbose, changed_only=not args.all
    )
    print(text, end="")

    saved = _save_report(args, text, store)
    if saved is not None:
        print(f"\nレポート: {saved}")

    return EXIT_CONFLICT if plan.conflicts else EXIT_OK


def _write(
    args: argparse.Namespace,
    plan: merger.Plan,
    mine: Path,
    out: Path | None,
    store: Path,
) -> tuple[Path | None, int]:
    """計画を反映する。--in-place なら先にバックアップを取る。"""
    if args.in_place:
        # ここが唯一 mine を書き換える経路。取り消せるように必ず先に退避する。
        snap = snapshot.create(
            mine,
            store,
            message=f"in-place 前 ({mine.name})",
            kind=snapshot.BACKUPS,
        )
        is_tree = mine.is_dir()
        # ファイル単位なら書き込みルートは親。空ディレクトリの掃除も、
        # 自分の管理下ではない親に対して行ってはいけない。
        root = mine if is_tree else mine.parent
        written = merger.apply(plan, root, in_place=True, prune=is_tree)
        return snap.path, written

    assert out is not None  # cmd_merge の入口で検証済み
    # ツリー単位なら --out そのものが出力ルート。ファイル単位では --out が
    # ファイル名なので、ルートはその親になる (名前は plan 側の rel が持つ)。
    root = out if mine.is_dir() else out.parent
    root.mkdir(parents=True, exist_ok=True)
    return None, merger.apply(plan, root)


def _save_report(args: argparse.Namespace, text: str, store: Path) -> Path | None:
    if args.no_report:
        return None
    if args.report:
        path = Path(args.report).expanduser().resolve()
        path.parent.mkdir(parents=True, exist_ok=True)
        path.write_text(text, encoding="utf-8")
        return path
    if args.dry_run:
        return None  # 書き込みゼロを謳っているので、レポートも残さない
    return report.save(text, snapshot.reports_dir(store))


# --------------------------------------------------------------------------


def main(argv: list[str] | None = None) -> int:
    _prepare_streams()
    parser = build_parser()
    args = parser.parse_args(argv)

    if not getattr(args, "func", None):
        parser.print_help()
        return EXIT_ERROR

    try:
        return args.func(args)
    except UserError as exc:
        _err(str(exc))
        return EXIT_ERROR
    except (OSError, ValueError) as exc:
        _err(str(exc))
        return EXIT_ERROR
    except KeyboardInterrupt:
        _err("中断しました。")
        return EXIT_ERROR


if __name__ == "__main__":
    sys.exit(main())

#@@ likegit-bundle @@ likegit/diff3.py @@ 5d1fac4ca3d4de44e18101be28a5e5c259008b7850f2207fb60cb60c80cf9dea
"""マージ中核。純粋関数のみで、ファイル I/O は一切持たない。

アルゴリズムは古典的な diff3:

  1. base↔mine と base↔theirs の 2 本の差分を取る
  2. 両者が「同時に base と一致している」区間 = 同期区間 を求める
  3. 同期区間の隙間 (不安定区間) を 4 通りに判定する
       mine == theirs  -> 同じ変更なので採用
       theirs == base  -> 相手は無変更 -> mine を採用
       mine == base    -> 自分は無変更 -> theirs を採用
       それ以外        -> 衝突
"""

from __future__ import annotations

from dataclasses import dataclass
from difflib import SequenceMatcher
from typing import Iterator, Sequence, Union

Lines = Sequence[str]

#: 衝突マーカー。長さ 7 は git と同じ。
MARK_MINE = "<<<<<<<"
MARK_BASE = "|||||||"
MARK_SPLIT = "======="
MARK_THEIRS = ">>>>>>>"


@dataclass(frozen=True)
class Stable:
    """自動的に決着した区間。"""

    lines: tuple[str, ...]
    origin: str  # "unchanged" | "same" | "mine" | "theirs"


@dataclass(frozen=True)
class Conflict:
    """人間の判断が必要な区間。"""

    base: tuple[str, ...]
    mine: tuple[str, ...]
    theirs: tuple[str, ...]


# ここは注釈ではなく実行時に評価されるので、`Stable | Conflict` と書くと
# Python 3.10 以上が必須になる。持ち込み先の Python を選べないため、
# 動く範囲を広く取って typing.Union を使う。
Region = Union[Stable, Conflict]


def _equal(a: Lines, a0: int, a1: int, b: Lines, b0: int, b1: int) -> bool:
    if (a1 - a0) != (b1 - b0):
        return False
    return all(a[a0 + i] == b[b0 + i] for i in range(a1 - a0))


def _sync_regions(
    base: Lines, mine: Lines, theirs: Lines
) -> list[tuple[int, int, int, int, int, int]]:
    """3 者が同時に一致する区間を (base開始, base終了, mine開始, ..., theirs終了) で返す。

    base↔mine と base↔theirs の一致ブロックを base 座標上で交差させ、
    重なった部分だけを取り出す。
    """
    # autojunk=False は必須。既定の autojunk は「頻出要素をノイズ扱い」するため、
    # 空行や "}" が多いソースコードで差分の質が壊滅的に落ちる。
    a_blocks = SequenceMatcher(None, base, mine, autojunk=False).get_matching_blocks()
    b_blocks = SequenceMatcher(None, base, theirs, autojunk=False).get_matching_blocks()

    regions: list[tuple[int, int, int, int, int, int]] = []
    ia = ib = 0
    while ia < len(a_blocks) and ib < len(b_blocks):
        a_base, a_mine, a_len = a_blocks[ia]
        b_base, b_theirs, b_len = b_blocks[ib]

        # base 座標上での交差区間
        start = max(a_base, b_base)
        end = min(a_base + a_len, b_base + b_len)
        if start < end:
            length = end - start
            m_start = a_mine + (start - a_base)
            t_start = b_theirs + (start - b_base)
            regions.append(
                (start, end, m_start, m_start + length, t_start, t_start + length)
            )

        # base 上で先に終わる方を進める
        if a_base + a_len < b_base + b_len:
            ia += 1
        else:
            ib += 1

    # 末尾番兵。最後の不安定区間を閉じるために必要。
    regions.append((len(base), len(base), len(mine), len(mine), len(theirs), len(theirs)))
    return regions


def _classify(
    base: Lines,
    mine: Lines,
    theirs: Lines,
    z0: int,
    z1: int,
    m0: int,
    m1: int,
    t0: int,
    t1: int,
) -> Region:
    same = _equal(mine, m0, m1, theirs, t0, t1)
    if same:
        return Stable(tuple(mine[m0:m1]), "same")

    mine_untouched = _equal(mine, m0, m1, base, z0, z1)
    theirs_untouched = _equal(theirs, t0, t1, base, z0, z1)

    if theirs_untouched:
        return Stable(tuple(mine[m0:m1]), "mine")
    if mine_untouched:
        return Stable(tuple(theirs[t0:t1]), "theirs")
    return Conflict(tuple(base[z0:z1]), tuple(mine[m0:m1]), tuple(theirs[t0:t1]))


def _minimize(conflict: Conflict) -> list[Region]:
    """衝突区間の先頭・末尾から、mine と theirs で一致する行を外へ出す。

    base 側が食い違う位置では打ち切る。そうしないと --diff3 出力で
    BASE セクションだけ行数がずれ、読み手を誤解させる。
    """
    base = list(conflict.base)
    mine = list(conflict.mine)
    theirs = list(conflict.theirs)

    head: list[str] = []
    while mine and theirs and mine[0] == theirs[0]:
        if base:
            if base[0] != mine[0]:
                break
            base.pop(0)
        head.append(mine.pop(0))
        theirs.pop(0)

    tail: list[str] = []
    while mine and theirs and mine[-1] == theirs[-1]:
        if base:
            if base[-1] != mine[-1]:
                break
            base.pop()
        tail.insert(0, mine.pop())
        theirs.pop()

    out: list[Region] = []
    if head:
        out.append(Stable(tuple(head), "same"))
    if mine or theirs or base:
        out.append(Conflict(tuple(base), tuple(mine), tuple(theirs)))
    if tail:
        out.append(Stable(tuple(tail), "same"))
    return out


def merge3(base: Lines, mine: Lines, theirs: Lines) -> list[Region]:
    """3-way マージした結果を区間の列として返す。

    base に空列を渡せば 2-way マージになる (一致部分のみ自動決着し、
    残りはすべて衝突)。
    """
    regions: list[Region] = []
    iz = im = it = 0

    for z0, z1, m0, m1, t0, t1 in _sync_regions(base, mine, theirs):
        # 同期区間の手前 = 不安定区間
        if im < m0 or it < t0 or iz < z0:
            region = _classify(base, mine, theirs, iz, z0, im, m0, it, t0)
            if isinstance(region, Conflict):
                regions.extend(_minimize(region))
            elif region.lines:
                regions.append(region)

        if z1 > z0:
            regions.append(Stable(tuple(base[z0:z1]), "unchanged"))

        iz, im, it = z1, m1, t1

    return _coalesce(regions)


def _coalesce(regions: list[Region]) -> list[Region]:
    """隣接する Stable を束ねて、レポートと出力を読みやすくする。"""
    merged: list[Region] = []
    for region in regions:
        if (
            isinstance(region, Stable)
            and merged
            and isinstance(merged[-1], Stable)
            and merged[-1].origin == region.origin
        ):
            merged[-1] = Stable(merged[-1].lines + region.lines, region.origin)
        else:
            merged.append(region)
    return merged


def count_conflicts(regions: Sequence[Region]) -> int:
    return sum(1 for r in regions if isinstance(r, Conflict))


def render(
    regions: Sequence[Region],
    label_mine: str = "MINE",
    label_theirs: str = "THEIRS",
    label_base: str = "BASE",
    show_base: bool = False,
) -> list[str]:
    """区間の列を、衝突マーカー入りの行の配列に展開する。"""
    out: list[str] = []
    for region in regions:
        if isinstance(region, Stable):
            out.extend(region.lines)
            continue
        out.append(f"{MARK_MINE} {label_mine}")
        out.extend(region.mine)
        if show_base:
            out.append(f"{MARK_BASE} {label_base}")
            out.extend(region.base)
        out.append(MARK_SPLIT)
        out.extend(region.theirs)
        out.append(f"{MARK_THEIRS} {label_theirs}")
    return out


def iter_conflicts(
    regions: Sequence[Region], show_base: bool = False
) -> Iterator[tuple[int, Conflict]]:
    """(出力行番号 1 始まり, 衝突) を順に返す。レポートで位置を示すため。

    行番号は render() が同じ show_base で出力した結果に対応する。
    """
    line_no = 1
    for region in regions:
        if isinstance(region, Stable):
            line_no += len(region.lines)
            continue
        yield line_no, region
        # マーカー 3 行 + 両者の行数。--diff3 なら BASE 見出しと base の行が増える。
        line_no += len(region.mine) + len(region.theirs) + 3
        if show_base:
            line_no += len(region.base) + 1


def has_marker(lines: Lines) -> bool:
    """既に衝突マーカーらしき行を含むか。誤認を警告するために使う。"""
    return any(
        line.startswith((MARK_MINE, MARK_SPLIT, MARK_THEIRS)) for line in lines
    )

#@@ likegit-bundle @@ likegit/merger.py @@ 3dbd660aea3a56c44ef0bc82a13b9cf58fb856deeffef67f0d51b20e3c3a54e0
"""ファイル単位・ツリー単位のマージ手続き。

「何を書くか」を決める計画フェーズ (plan_*) と、実際に書く実行フェーズ (apply)
を分けている。--dry-run が特別扱いなしに成立し、計画をそのままレポートに
流用できるため。
"""

from __future__ import annotations

import os
import shutil
from dataclasses import dataclass, field
from pathlib import Path, PurePosixPath
from typing import Sequence

from . import diff3, scanner, textio, winpath

ACTION_UNCHANGED = "変更なし"
ACTION_SAME_CHANGE = "両者が同じ変更"
ACTION_AUTO = "自動マージ"
ACTION_MINE = "自分の版を採用"
ACTION_THEIRS = "相手の版を採用"
ACTION_ADDED_MINE = "自分が追加"
ACTION_ADDED_THEIRS = "相手が追加"
ACTION_ADDED_BOTH = "両者が追加(同一)"
ACTION_DELETED = "削除"
ACTION_CONFLICT = "衝突"
ACTION_BINARY_CONFLICT = "衝突(バイナリ)"
ACTION_DELETE_CONFLICT = "衝突(削除と変更)"

CONFLICT_ACTIONS = frozenset(
    {ACTION_CONFLICT, ACTION_BINARY_CONFLICT, ACTION_DELETE_CONFLICT}
)


@dataclass(frozen=True)
class Write:
    """出力先に書く 1 ファイル分。data か src のどちらかを持つ。"""

    rel: str
    data: bytes | None = None
    src: Path | None = None


@dataclass
class Outcome:
    path: str
    action: str
    conflicts: int = 0
    notes: list[str] = field(default_factory=list)
    writes: tuple[Write, ...] = ()
    delete: bool = False
    same_as_mine: bool = True
    conflict_lines: tuple[int, ...] = ()  # 出力ファイル内でマーカーが始まる行番号

    @property
    def is_conflict(self) -> bool:
        return self.action in CONFLICT_ACTIONS


@dataclass
class Labels:
    mine: str = "MINE"
    theirs: str = "THEIRS"
    base: str = "BASE"


@dataclass
class Options:
    labels: Labels = field(default_factory=Labels)
    show_base: bool = False
    prefer: str | None = None  # None | "mine" | "theirs" — 衝突時の自動採用


@dataclass
class Plan:
    outcomes: list[Outcome] = field(default_factory=list)
    warnings: list[str] = field(default_factory=list)
    has_base: bool = True

    @property
    def conflicts(self) -> list[Outcome]:
        return [o for o in self.outcomes if o.is_conflict]

    def counts(self) -> dict[str, int]:
        tally: dict[str, int] = {}
        for outcome in self.outcomes:
            tally[outcome.action] = tally.get(outcome.action, 0) + 1
        return tally


# --------------------------------------------------------------------------
# ファイル単位
# --------------------------------------------------------------------------


def _sidecar(rel: str, label: str) -> str:
    """foo.xlsx -> foo.THEIRS.xlsx / Makefile -> Makefile.THEIRS"""
    path = PurePosixPath(rel)
    if path.suffix:
        return str(path.with_name(f"{path.stem}.{label}{path.suffix}"))
    return f"{rel}.{label}"


def _pick_format(
    mine: textio.TextFile | None,
    theirs: textio.TextFile | None,
    base: textio.TextFile | None,
) -> textio.TextFile:
    for candidate in (mine, theirs, base):
        if candidate is not None:
            return candidate
    raise ValueError("形式を決める材料がありません")


def _format_notes(
    mine: textio.TextFile | None, theirs: textio.TextFile | None
) -> list[str]:
    notes: list[str] = []
    if mine is None or theirs is None:
        return notes
    if mine.encoding != theirs.encoding:
        notes.append(
            f"文字コード相違 (自分={mine.encoding} 相手={theirs.encoding}) "
            f"→ 自分側 {mine.encoding} で保存"
        )
    if mine.newline != theirs.newline:
        notes.append(
            f"改行コード相違 (自分={textio.describe_newline(mine.newline)} "
            f"相手={textio.describe_newline(theirs.newline)}) → 自分側で保存"
        )
    return notes


def merge_text(
    rel: str,
    base: textio.TextFile | None,
    mine: textio.TextFile,
    theirs: textio.TextFile,
    options: Options,
) -> Outcome:
    base_lines = base.lines if base is not None else ()
    regions = diff3.merge3(base_lines, mine.lines, theirs.lines)
    conflicts = diff3.count_conflicts(regions)
    notes = _format_notes(mine, theirs)

    if conflicts and options.prefer:
        keep = options.prefer
        regions = [
            r
            if isinstance(r, diff3.Stable)
            else diff3.Stable(r.mine if keep == "mine" else r.theirs, keep)
            for r in regions
        ]
        notes.append(f"衝突 {conflicts} 件を --prefer {keep} で自動採用")
        conflicts = 0

    lines = diff3.render(
        regions,
        label_mine=options.labels.mine,
        label_theirs=options.labels.theirs,
        label_base=options.labels.base,
        show_base=options.show_base,
    )

    template = _pick_format(mine, theirs, base)
    merged = template.with_lines(lines)
    data = textio.render(merged)

    if conflicts:
        action = ACTION_CONFLICT
    elif tuple(lines) == tuple(mine.lines):
        action = ACTION_MINE
    elif tuple(lines) == tuple(theirs.lines):
        action = ACTION_THEIRS
    else:
        action = ACTION_AUTO

    if diff3.has_marker(mine.lines) or diff3.has_marker(theirs.lines):
        notes.append("入力に既に衝突マーカーらしき行があります。要確認")

    conflict_lines = tuple(
        line_no for line_no, _ in diff3.iter_conflicts(regions, options.show_base)
    )

    return Outcome(
        path=rel,
        action=action,
        conflicts=conflicts,
        notes=notes,
        writes=(Write(rel, data=data),),
        same_as_mine=(data == textio.render(mine)),
        conflict_lines=conflict_lines,
    )


def merge_binary(
    rel: str,
    base_path: Path | None,
    mine_path: Path,
    theirs_path: Path,
    options: Options,
) -> Outcome:
    mine_bytes = winpath.extend(mine_path).read_bytes()
    theirs_bytes = winpath.extend(theirs_path).read_bytes()

    if mine_bytes == theirs_bytes:
        return Outcome(rel, ACTION_UNCHANGED, writes=(Write(rel, src=mine_path),))

    base_bytes = (
        winpath.extend(base_path).read_bytes() if base_path is not None else None
    )
    if base_bytes is not None:
        if mine_bytes == base_bytes:
            return Outcome(
                rel, ACTION_THEIRS, writes=(Write(rel, src=theirs_path),), same_as_mine=False
            )
        if theirs_bytes == base_bytes:
            return Outcome(rel, ACTION_MINE, writes=(Write(rel, src=mine_path),))

    # 両者が別々に変更した。行マージはできないので自分の版を残し、
    # 相手の版を隣に置いて目視比較できるようにする。
    sidecar = _sidecar(rel, options.labels.theirs)
    return Outcome(
        rel,
        ACTION_BINARY_CONFLICT,
        conflicts=1,
        notes=[f"バイナリのため自動統合不可。相手の版を {sidecar} に置きました"],
        writes=(Write(rel, src=mine_path), Write(sidecar, src=theirs_path)),
        same_as_mine=False,
    )


def merge_pair(
    rel: str,
    base_path: Path | None,
    mine_path: Path,
    theirs_path: Path,
    options: Options,
) -> Outcome:
    """両側に存在するファイルをマージする。"""
    mine_text = textio.load(mine_path)
    theirs_text = textio.load(theirs_path)

    if mine_text is None or theirs_text is None:
        return merge_binary(rel, base_path, mine_path, theirs_path, options)

    base_text = textio.load(base_path) if base_path is not None else None
    if base_path is not None and base_text is None:
        # base だけバイナリ扱い。base 無しの 2-way に落とす。
        outcome = merge_text(rel, None, mine_text, theirs_text, options)
        outcome.notes.append("base がテキストとして読めないため 2-way マージしました")
        return outcome

    return merge_text(rel, base_text, mine_text, theirs_text, options)


# --------------------------------------------------------------------------
# ツリー単位
# --------------------------------------------------------------------------


def _same_bytes(a: Path, b: Path) -> bool:
    left, right = winpath.extend(a), winpath.extend(b)
    # サイズ違いは読まずに決着させる。ツリー全体で何度も呼ばれるため。
    try:
        if left.stat().st_size != right.stat().st_size:
            return False
    except OSError:
        pass
    return left.read_bytes() == right.read_bytes()


def _same_file(a: Path, b: Path) -> bool:
    """同じ実体を指すか。大小文字違いやシンボリックリンクも同一と見なす。"""
    if a == b:
        return True
    left, right = winpath.extend(a), winpath.extend(b)
    try:
        return right.exists() and os.path.samefile(left, right)
    except OSError:
        return False


def plan_tree(
    base_root: Path | None,
    mine_root: Path,
    theirs_root: Path,
    options: Options,
    rules: scanner.IgnoreRules | None = None,
) -> Plan:
    roots = [mine_root, theirs_root] + ([base_root] if base_root else [])
    rules = rules or scanner.load_ignore(roots)

    mine_files = scanner.scan(mine_root, rules)
    theirs_files = scanner.scan(theirs_root, rules)
    base_files = scanner.scan(base_root, rules) if base_root else {}

    plan = Plan(has_base=base_root is not None)
    if base_root is None:
        plan.warnings.append(
            "base を指定していないため 2-way マージです。"
            "差分はすべて衝突として扱われます。"
        )
    elif not base_files and (mine_files or theirs_files):
        # base はあるが空。指定ミスか、退避に失敗した控えを掴んでいる。
        # 黙って進むと 2-way と変わらない結果になり、原因に気づけない。
        plan.warnings.append(
            f"base ({base_root}) に 1 件もファイルがありません。"
            "3-way にならず、差分はすべて衝突になります。"
            "--base の指定が正しいか確認してください。"
        )

    for rel in sorted(set(mine_files) | set(theirs_files) | set(base_files)):
        mine = mine_files.get(rel)
        theirs = theirs_files.get(rel)
        base = base_files.get(rel)
        plan.outcomes.append(
            _plan_one(rel, base, mine, theirs, options, plan.has_base)
        )

    return plan


def _plan_one(
    rel: str,
    base: Path | None,
    mine: Path | None,
    theirs: Path | None,
    options: Options,
    has_base: bool,
) -> Outcome:
    # 両側にある: 内容をマージ
    if mine is not None and theirs is not None:
        if _same_bytes(mine, theirs):
            if base is None:
                # base があるのにこのパスに無い = 両者が新規作成した
                action = ACTION_ADDED_BOTH if has_base else ACTION_UNCHANGED
            elif _same_bytes(mine, base):
                action = ACTION_UNCHANGED
            else:
                # 両者が同じ修正をした。中身は決まるが「無変更」ではないので、
                # 受領内容を確かめる人のために区別して報告する。
                action = ACTION_SAME_CHANGE
            return Outcome(rel, action, writes=(Write(rel, src=mine),))
        return merge_pair(rel, base, mine, theirs, options)

    # 片側だけにある
    if mine is not None:  # theirs にはない
        if base is None:
            # base 自体が無い (2-way) なら単に自分側のファイル。
            # base はあるがこのパスに無いなら、自分が新規作成したファイル。
            action = ACTION_ADDED_MINE if has_base else ACTION_MINE
            return Outcome(rel, action, writes=(Write(rel, src=mine),))
        if _same_bytes(mine, base):
            # 相手が削除し、自分は触っていない → 削除に従う
            return Outcome(rel, ACTION_DELETED, delete=True, same_as_mine=False)
        return Outcome(
            rel,
            ACTION_DELETE_CONFLICT,
            conflicts=1,
            notes=["相手が削除、自分は変更。自分の版を残しました"],
            writes=(Write(rel, src=mine),),
        )

    if theirs is not None:  # mine にはない
        if base is None:
            return Outcome(
                rel,
                ACTION_ADDED_THEIRS,
                writes=(Write(rel, src=theirs),),
                same_as_mine=False,
            )
        if _same_bytes(theirs, base):
            # 自分が削除し、相手は触っていない → 削除を維持
            return Outcome(rel, ACTION_DELETED, delete=True)
        return Outcome(
            rel,
            ACTION_DELETE_CONFLICT,
            conflicts=1,
            notes=["自分が削除、相手は変更。相手の版を復活させました"],
            writes=(Write(rel, src=theirs),),
            same_as_mine=False,
        )

    # base にしかない = 両者が削除
    return Outcome(rel, ACTION_DELETED, delete=True)


def plan_files(
    base_path: Path | None,
    mine_path: Path,
    theirs_path: Path,
    options: Options,
    rel: str | None = None,
) -> Plan:
    """ファイル 2 つ (+base) を直接マージする計画。

    rel は出力先での名前。既定は mine のファイル名で、apply() の out_root
    からの相対パスとして解釈される。
    """
    plan = Plan(has_base=base_path is not None)
    if base_path is None:
        plan.warnings.append(
            "base を指定していないため 2-way マージです。"
            "差分はすべて衝突として扱われます。"
        )
    rel = rel or mine_path.name
    if _same_bytes(mine_path, theirs_path):
        plan.outcomes.append(
            Outcome(rel, ACTION_UNCHANGED, writes=(Write(rel, src=mine_path),))
        )
    else:
        plan.outcomes.append(merge_pair(rel, base_path, mine_path, theirs_path, options))
    return plan


# --------------------------------------------------------------------------
# 実行
# --------------------------------------------------------------------------


def apply(
    plan: Plan, out_root: Path, in_place: bool = False, prune: bool = True
) -> int:
    """計画を出力先へ反映し、書き込んだファイル数を返す。

    out_root は常にディレクトリ。ファイル単位のマージでは呼び出し側が
    親ディレクトリを渡し、ファイル名は Write.rel が持つ。

    prune=False は、out_root が自分の管理下でないとき (ファイル単位の
    --in-place など) に指定する。無関係な空ディレクトリを消さないため。
    """
    written = 0
    emptied: list[Path] = []  # 削除でファイルが減ったディレクトリ
    for outcome in plan.outcomes:
        if outcome.delete:
            if in_place:
                target = out_root / outcome.path
                if winpath.extend(target).is_file():
                    winpath.extend(target).unlink()
                    written += 1
                    emptied.append(target.parent)
            continue

        if in_place and outcome.same_as_mine:
            continue  # 内容が変わらないなら触らない (mtime を保つ)

        for write in outcome.writes:
            # 出力先は元のパスより長くなりうる。I/O は winpath 経由で行い、
            # 保持・表示するパス (target) は接頭辞なしのままにする。
            target = out_root / write.rel
            winpath.extend(target.parent).mkdir(parents=True, exist_ok=True)
            if write.data is not None:
                winpath.extend(target).write_bytes(write.data)
            elif write.src is not None:
                # --in-place では src と書き込み先が同一ファイルになりうる
                # (バイナリ衝突で mine 側を残す場合など)。Windows の CopyFile2 は
                # 自分自身へのコピーを「使用中」エラーにするので、先に弾く。
                if _same_file(write.src, target):
                    continue
                shutil.copy2(winpath.extend(write.src), winpath.extend(target))
            written += 1

    if in_place and prune:
        _prune_empty_dirs(out_root, emptied)
    return written


def _prune_empty_dirs(root: Path, emptied: Sequence[Path]) -> None:
    """削除の結果 空になったディレクトリだけを片付ける。ルート自身は残す。

    ツリー全体を走査して空ディレクトリを消してはいけない。元から意図的に
    空だったフォルダ (置き場所として用意した logs/ など) まで巻き込む。
    自分が消したファイルの親から上へ辿り、空である限りだけ畳む。
    """
    root = root.resolve()
    for start in emptied:
        path = start
        while path.resolve() != root:
            probe = winpath.extend(path)
            try:
                if not probe.is_dir() or any(probe.iterdir()):
                    break
                probe.rmdir()
            except OSError:
                break
            path = path.parent

#@@ likegit-bundle @@ likegit/report.py @@ 309a88d148f47d4ea1487c7b5f3762330f991c84918c6bcab21477d443f4fa1a
"""結果の集計と整形。

Plan (merger.plan_*) だけを入力に取り、文字列を返す純粋な層。ファイルへの
書き出しは呼び出し側が決める。--dry-run と本実行でまったく同じレポートが
出せるのは、この層が実行結果ではなく計画を見ているため。

読み手が最初に知りたいのは「手で直す場所はどこか」なので、衝突を先に、
集計と全件一覧を後に置く。
"""

from __future__ import annotations

from dataclasses import dataclass, field
from datetime import datetime
from pathlib import Path

from . import merger

#: 集計を出す順序。辞書のキー順に頼ると環境で揺れるので明示する。
ACTION_ORDER: tuple[str, ...] = (
    merger.ACTION_UNCHANGED,
    merger.ACTION_SAME_CHANGE,
    merger.ACTION_AUTO,
    merger.ACTION_MINE,
    merger.ACTION_THEIRS,
    merger.ACTION_ADDED_MINE,
    merger.ACTION_ADDED_THEIRS,
    merger.ACTION_ADDED_BOTH,
    merger.ACTION_DELETED,
    merger.ACTION_CONFLICT,
    merger.ACTION_BINARY_CONFLICT,
    merger.ACTION_DELETE_CONFLICT,
)

#: 衝突箇所の行番号を並べる上限。これ以上はファイルを開いて見た方が早い。
MAX_LINES_SHOWN = 8


@dataclass
class Context:
    """レポートの見出しに載せる、そのマージ 1 回分の状況。"""

    mine: Path
    theirs: Path
    base: Path | None = None
    base_spec: str | None = None  # ユーザーが --base に書いた文字列
    out: Path | None = None
    in_place: bool = False
    dry_run: bool = False
    backup: Path | None = None
    written: int | None = None
    created_at: str = field(default_factory=lambda: datetime.now().isoformat(timespec="seconds"))


def _rows(pairs: list[tuple[str, str]], indent: str = "  ") -> list[str]:
    """左列の幅を揃えて "key : value" を並べる。"""
    if not pairs:
        return []
    width = max(display_width(key) for key, _ in pairs)
    return [f"{indent}{key}{' ' * (width - display_width(key))} : {value}" for key, value in pairs]


def display_width(text: str) -> int:
    """全角を 2 桁として数える。日本語の見出しと ASCII が混ざるため。"""
    return sum(2 if ord(ch) > 0x2000 else 1 for ch in text)


def pad(text: str, width: int) -> str:
    return text + " " * max(0, width - display_width(text))


def header(context: Context) -> list[str]:
    pairs: list[tuple[str, str]] = []
    if context.base is not None:
        label = str(context.base)
        if context.base_spec and context.base_spec != str(context.base):
            label = f"{context.base_spec}  ({context.base})"
        pairs.append(("base", label))
    else:
        pairs.append(("base", "なし (2-way)"))
    pairs.append(("mine", str(context.mine)))
    pairs.append(("theirs", str(context.theirs)))
    if context.in_place:
        pairs.append(("out", f"{context.mine}  (--in-place)"))
    elif context.out is not None:
        pairs.append(("out", str(context.out)))
    if context.backup is not None:
        pairs.append(("backup", str(context.backup)))
    pairs.append(("日時", context.created_at))

    lines = ["likegit merge レポート"]
    if context.dry_run:
        lines.append("  ** --dry-run: 何も書き込んでいません **")
    lines.extend(_rows(pairs))
    return lines


def counts_block(plan: merger.Plan) -> list[str]:
    tally = plan.counts()
    known = [(action, tally[action]) for action in ACTION_ORDER if action in tally]
    extra = [(a, n) for a, n in sorted(tally.items()) if a not in ACTION_ORDER]
    rows = known + extra
    if not rows:
        return ["[集計]", "  対象ファイルがありません"]

    width = max(display_width(action) for action, _ in rows)
    lines = ["[集計]"]
    lines += [f"  {pad(action, width)}  {count:>5}" for action, count in rows]
    lines.append(f"  {pad('合計', width)}  {len(plan.outcomes):>5}")
    return lines


def _conflict_detail(outcome: merger.Outcome) -> str:
    if outcome.conflict_lines:
        shown = outcome.conflict_lines[:MAX_LINES_SHOWN]
        text = ", ".join(str(n) for n in shown)
        if len(outcome.conflict_lines) > len(shown):
            text += ", ..."
        return f"{outcome.conflicts} 箇所 (行 {text})"
    if outcome.conflicts:
        return f"{outcome.conflicts} 箇所"
    return ""


def conflicts_block(plan: merger.Plan) -> list[str]:
    conflicts = plan.conflicts
    if not conflicts:
        return []

    # CP932 のコンソールでも化けないよう、記号は ASCII に留める。
    lines = [f"[衝突] {len(conflicts)} 件 -- 手で直してください"]
    width = max(display_width(o.path) for o in conflicts)
    for outcome in conflicts:
        detail = _conflict_detail(outcome)
        lines.append(f"  {pad(outcome.path, width)}  {outcome.action}  {detail}".rstrip())
        lines += [f"  {' ' * width}    - {note}" for note in outcome.notes]
    return lines


def notes_block(plan: merger.Plan) -> list[str]:
    """衝突していないが注意書きが付いたファイル。文字コード相違など。"""
    noted = [o for o in plan.outcomes if o.notes and not o.is_conflict]
    if not noted:
        return []
    lines = ["[備考]"]
    for outcome in noted:
        lines.append(f"  {outcome.path}")
        lines += [f"    - {note}" for note in outcome.notes]
    return lines


def listing_block(plan: merger.Plan, changed_only: bool = False) -> list[str]:
    outcomes = plan.outcomes
    if changed_only:
        outcomes = [o for o in outcomes if o.action != merger.ACTION_UNCHANGED]
    if not outcomes:
        return []
    title = "[全ファイル]" if not changed_only else "[変更のあったファイル]"
    width = max(display_width(o.path) for o in outcomes)
    lines = [title]
    lines += [f"  {pad(o.path, width)}  {o.action}" for o in outcomes]
    return lines


def verdict(plan: merger.Plan, context: Context) -> str:
    conflicts = plan.conflicts
    if conflicts:
        total = sum(o.conflicts for o in conflicts)
        head = f"結果: 衝突 {len(conflicts)} ファイル / {total} 箇所。"
        where = context.mine if context.in_place else context.out
        if where is None:
            # --dry-run で出力先を指定しなかった場合。開くべき場所がまだ無い。
            return head + "出力先を決めて実行し直してください。"
        return head + f"{where} を開いて <<<<<<< を解決してください。"
    if context.dry_run:
        return "結果: 衝突なし。--dry-run のため書き込んでいません。"
    if context.written is not None:
        return f"結果: 衝突なし。{context.written} ファイルを書き出しました。"
    return "結果: 衝突なし。"


def render(
    plan: merger.Plan,
    context: Context,
    verbose: bool = False,
    changed_only: bool = True,
) -> str:
    """レポート全文を組み立てる。"""
    blocks: list[list[str]] = [header(context)]

    if plan.warnings:
        blocks.append(["[警告]"] + [f"  - {w}" for w in plan.warnings])

    blocks.append(conflicts_block(plan))
    blocks.append(notes_block(plan))
    blocks.append(counts_block(plan))
    if verbose:
        blocks.append(listing_block(plan, changed_only=changed_only))
    blocks.append([verdict(plan, context)])

    return "\n\n".join("\n".join(block) for block in blocks if block) + "\n"


def save(text: str, directory: Path, stamp: str | None = None) -> Path:
    """レポートをファイルに残す。あとから「何を統合したか」を追えるようにする。"""
    stamp = stamp or datetime.now().strftime("%Y%m%d-%H%M%S")
    directory.mkdir(parents=True, exist_ok=True)
    path = directory / f"{stamp}_merge.txt"
    # 同一秒に複数回走らせても上書きしない
    suffix = 2
    while path.exists():
        path = directory / f"{stamp}_merge-{suffix}.txt"
        suffix += 1
    path.write_text(text, encoding="utf-8")
    return path

#@@ likegit-bundle @@ likegit/scanner.py @@ 1d2e7dd7a4699d7c0a8171af227b834fac74502a939ebd0b48becadd37b7060c
"""ディレクトリ走査と除外ルール。"""

from __future__ import annotations

import fnmatch
import os
from pathlib import Path
from typing import Sequence

from . import winpath

#: 既定の除外パターン。末尾 "/" はディレクトリ名にのみ一致する。
DEFAULT_IGNORE: tuple[str, ...] = (
    ".git/",
    ".svn/",
    ".hg/",
    ".likegit/",
    "__pycache__/",
    "node_modules/",
    ".venv/",
    "venv/",
    ".mypy_cache/",
    ".pytest_cache/",
    ".idea/",
    ".vscode/",
    "*.pyc",
    "*.pyo",
    "*.class",
    "*.o",
    "*.obj",
    ".DS_Store",
    "Thumbs.db",
    "~$*",  # Excel/Word のロックファイル
)

IGNORE_FILE = ".likegitignore"


class IgnoreRules:
    """.gitignore の簡略版。fnmatch ベースで、否定 (!) は扱わない。"""

    def __init__(self, patterns: Sequence[str] = ()) -> None:
        self.dir_patterns: list[str] = []
        self.path_patterns: list[str] = []
        self.name_patterns: list[str] = []
        self.add(patterns)

    def add(self, patterns: Sequence[str]) -> None:
        for raw in patterns:
            pattern = raw.strip()
            if not pattern or pattern.startswith("#"):
                continue
            if pattern.endswith("/"):
                self.dir_patterns.append(pattern[:-1])
            elif "/" in pattern.strip("/"):
                self.path_patterns.append(pattern.lstrip("/"))
            else:
                self.name_patterns.append(pattern)

    def _matches_common(self, relpath: str, name: str) -> bool:
        # fnmatch は Windows では大小文字を無視する。ここではそれが望ましい。
        if any(fnmatch.fnmatch(name, p) for p in self.name_patterns):
            return True
        return any(fnmatch.fnmatch(relpath, p) for p in self.path_patterns)

    def match_dir(self, relpath: str, name: str) -> bool:
        if any(fnmatch.fnmatch(name, p) for p in self.dir_patterns):
            return True
        return self._matches_common(relpath, name)

    def match_file(self, relpath: str, name: str) -> bool:
        return self._matches_common(relpath, name)


def load_ignore(roots: Sequence[Path], use_defaults: bool = True) -> IgnoreRules:
    """既定パターンと、各ルート直下の .likegitignore を読み込む。"""
    rules = IgnoreRules(DEFAULT_IGNORE if use_defaults else ())
    for root in roots:
        ignore_file = root / IGNORE_FILE
        if ignore_file.is_file():
            rules.add(ignore_file.read_text(encoding="utf-8").splitlines())
    return rules


def scan(root: Path, rules: IgnoreRules) -> dict[str, Path]:
    """相対パス (区切りは "/") -> 実パス の辞書を返す。

    シンボリックリンクとディレクトリ以外の特殊ファイルは黙って飛ばす。
    """
    found: dict[str, Path] = {}
    root = root.resolve()

    # 走査は winpath 経由。base の退避先は元より 40〜80 文字長く、
    # 深いプロジェクトでは 260 文字を超えて os.walk が何も返さなくなる。
    # 返ってくるパスは接頭辞なしなので、以降の扱いは変わらない。
    for dirpath, dirnames, filenames in winpath.walk(root):
        rel_dir = os.path.relpath(dirpath, root)
        rel_dir = "" if rel_dir == "." else rel_dir.replace(os.sep, "/")

        kept = []
        for name in dirnames:
            rel = f"{rel_dir}/{name}" if rel_dir else name
            if not rules.match_dir(rel, name):
                kept.append(name)
        dirnames[:] = kept

        for name in filenames:
            rel = f"{rel_dir}/{name}" if rel_dir else name
            if rules.match_file(rel, name):
                continue
            path = Path(dirpath) / name
            probe = winpath.extend(path)  # 判定だけ接頭辞付きで行う
            if probe.is_symlink() or not probe.is_file():
                continue
            found[rel] = path  # 保持するのは接頭辞なしのパス

    return found

#@@ likegit-bundle @@ likegit/snapshot.py @@ d7b48fc1a01cbeb316525eb283fd3e1d01431d04cdf9aabd0bec922a50024630
"""base スナップショットの保存・列挙・解決。

git の代わりに「共通の出発点」を手元に持つための、最小限の仕組み。
中身はただのファイルコピー + meta.json で、独自形式は一切使わない。
壊れてもエクスプローラで中を開けることを優先している。
"""

from __future__ import annotations

import json
import os
import re
import shutil
from dataclasses import dataclass
from datetime import datetime
from pathlib import Path

from . import scanner, winpath

STORE_DIRNAME = ".likegit"
SNAPSHOTS = "snapshots"
BACKUPS = "backups"
REPORTS = "reports"
TREE = "tree"
META = "meta.json"

# 日本語のメモをそのまま名前に残したいので、許可リストではなく
# 「ファイル名に使えない文字」だけを落とす。Windows の禁止文字と制御文字。
_SLUG_RE = re.compile(r'[<>:"/\\|?*\x00-\x1f]+')
_SPACE_RE = re.compile(r"\s+")
#: 末尾のピリオドと空白は Windows が黙って削るため、こちらで先に落とす。
_TRIM = " .-_"


@dataclass(frozen=True)
class Snapshot:
    name: str
    path: Path  # スナップショットのディレクトリ (tree/ と meta.json を含む)
    source: str
    message: str
    created_at: str
    file_count: int

    @property
    def tree(self) -> Path:
        return self.path / TREE


def store_root(explicit: str | None = None) -> Path:
    """スナップショット置き場を決める。--store > 環境変数 > カレント直下。"""
    if explicit:
        return Path(explicit).expanduser().resolve()
    env = os.environ.get("LIKEGIT_DIR")
    if env:
        return Path(env).expanduser().resolve()
    return Path.cwd() / STORE_DIRNAME


def _slugify(text: str, limit: int = 40) -> str:
    slug = _SLUG_RE.sub("-", text)
    slug = _SPACE_RE.sub("-", slug).strip(_TRIM)
    return slug[:limit].strip(_TRIM)


def create(
    source: Path,
    store: Path,
    message: str = "",
    name: str | None = None,
    kind: str = SNAPSHOTS,
) -> Snapshot:
    """source を丸ごと退避する。ディレクトリでも単一ファイルでもよい。

    単一ファイルを許すのは、--in-place のバックアップがファイル単位のマージでも
    必要になるため。tree/ の下に元の名前で 1 つ置くだけで、構造は変わらない。
    """
    source = source.resolve()
    if not source.exists():
        raise FileNotFoundError(f"見つかりません: {source}")

    timestamp = datetime.now()
    if name is None:
        name = timestamp.strftime("%Y%m%d-%H%M%S")
        suffix = _slugify(message)
        if suffix:
            name = f"{name}_{suffix}"

    dest = store / kind / name
    if dest.exists():
        raise FileExistsError(f"同名のスナップショットが既にあります: {dest}")

    if source.is_dir():
        rules = scanner.load_ignore([source])
        files = scanner.scan(source, rules)
    else:
        files = {source.name: source}

    tree = dest / TREE
    for rel, path in files.items():
        # 退避先は元より 40〜80 文字長い。Windows の 260 文字制限に当たるので
        # I/O は winpath 経由で行う (winpath.py の説明を参照)。
        target = tree / rel
        winpath.extend(target.parent).mkdir(parents=True, exist_ok=True)
        shutil.copy2(winpath.extend(path), winpath.extend(target))
    winpath.extend(tree).mkdir(parents=True, exist_ok=True)  # 空でも tree/ は作る

    meta = {
        "name": name,
        "source": str(source),
        "message": message,
        "created_at": timestamp.isoformat(timespec="seconds"),
        "file_count": len(files),
    }
    (dest / META).write_text(
        json.dumps(meta, ensure_ascii=False, indent=2), encoding="utf-8"
    )
    return _from_meta(dest, meta)


def _from_meta(path: Path, meta: dict) -> Snapshot:
    return Snapshot(
        name=meta.get("name", path.name),
        path=path,
        source=meta.get("source", ""),
        message=meta.get("message", ""),
        created_at=meta.get("created_at", ""),
        file_count=int(meta.get("file_count", 0)),
    )


def load(path: Path) -> Snapshot | None:
    meta_path = path / META
    if not meta_path.is_file():
        return None
    try:
        meta = json.loads(meta_path.read_text(encoding="utf-8"))
    except (json.JSONDecodeError, OSError):
        return None
    return _from_meta(path, meta)


def listing(store: Path, kind: str = SNAPSHOTS) -> list[Snapshot]:
    base = store / kind
    if not base.is_dir():
        return []
    found = [load(child) for child in sorted(base.iterdir()) if child.is_dir()]
    return [s for s in found if s is not None]


def resolve_base(spec: str, store: Path) -> Path:
    """--base の指定を実パスに解決する。

    実在するパスならそのまま (ファイル単位のマージでは base もファイル)。
    そうでなければスナップショット名として探す。
    """
    candidate = Path(spec).expanduser()
    if candidate.is_file():
        return candidate.resolve()
    if candidate.is_dir():
        snap = load(candidate)
        return snap.tree if snap else candidate.resolve()

    for kind in (SNAPSHOTS, BACKUPS):
        snap_dir = store / kind / spec
        if snap_dir.is_dir():
            snap = load(snap_dir)
            if snap:
                return snap.tree
            return snap_dir

    raise FileNotFoundError(
        f"base が見つかりません: {spec}\n"
        f"  パス、または `likegit snapshots` に出る名前を指定してください。"
    )


def reports_dir(store: Path) -> Path:
    path = store / REPORTS
    path.mkdir(parents=True, exist_ok=True)
    return path

#@@ likegit-bundle @@ likegit/textio.py @@ df1340ceecdbee5e4da5d236a83ecb00be9b4c40ba4901f6d130536342aa6853
"""テキストファイルの読み書きと、その形式の保存・復元。

比較は「改行コードを剥がした行の配列」に対して行い、書き戻すときに元の形式
(改行コード・エンコーディング・BOM・末尾改行) を復元する。この分離をしないと、
日本語 Windows 環境で「1 行も変えていないのにファイル全体が差分になる」事故が
起きる。
"""

from __future__ import annotations

import codecs
import re
from dataclasses import dataclass, replace
from pathlib import Path

from . import winpath

# 試行順序に意味がある。UTF-8 として妥当なバイト列が CP932 としても妥当なことは
# 稀なので、UTF-8 を先に試すのが安全側。逆順にすると UTF-8 の日本語が
# 文字化けしたまま「読めた」ことになる。
#
# ここに "utf-8-sig" を混ぜてはいけない。utf-8-sig は BOM が無いバイト列も
# 問題なく復号するため、候補に並べると BOM の無いファイルまで utf-8-sig と
# 判定され、保存時に BOM を付け足してしまう。BOM の有無は下で直接見る。
CANDIDATE_ENCODINGS = ("utf-8", "cp932", "euc_jp")

# UTF-16/32 は NUL バイトを含むので is_binary() でバイナリ扱いになる。
# 行マージの対象にしないという意味で、これは意図した挙動。
BOM_UTF8 = codecs.BOM_UTF8

BINARY_SNIFF_SIZE = 8192

_NEWLINE_RE = re.compile(r"\r\n|\r|\n")


@dataclass(frozen=True)
class TextFile:
    """テキストファイルの内容と、復元に必要な形式情報。"""

    lines: tuple[str, ...]  # 改行コードを含まない行
    encoding: str
    newline: str  # "\r\n" | "\n" | "\r"
    final_newline: bool  # 末尾に改行があるか

    def with_lines(self, lines) -> "TextFile":
        return replace(self, lines=tuple(lines))


def is_binary(data: bytes) -> bool:
    """NUL バイトの有無で判定する。テキストエディタ各種と同じ簡便法。"""
    return b"\x00" in data[:BINARY_SNIFF_SIZE]


def decode(data: bytes) -> tuple[str, str] | None:
    """(text, encoding) を返す。どの候補でも復号できなければ None。

    返す encoding は render() でそのまま符号化に使うため、"utf-8-sig" は
    実際に BOM があるときだけ返す。
    """
    if data.startswith(BOM_UTF8):
        try:
            return data.decode("utf-8-sig"), "utf-8-sig"
        except UnicodeDecodeError:
            pass  # BOM だけ一致した別物。通常の候補で読み直す
    for enc in CANDIDATE_ENCODINGS:
        try:
            return data.decode(enc), enc
        except UnicodeDecodeError:
            continue
    return None


def detect_newline(text: str) -> str:
    crlf = text.count("\r\n")
    lf = text.count("\n") - crlf
    cr = text.count("\r") - crlf
    if crlf >= lf and crlf >= cr and crlf > 0:
        return "\r\n"
    if cr > lf:
        return "\r"
    return "\n"


def split_lines(text: str) -> tuple[tuple[str, ...], bool]:
    """行に分割し、(lines, 末尾改行の有無) を返す。

    str.splitlines() は \\x0b や \\u2028 でも分割してしまい、"\\n" で繋ぎ直すと
    ファイルが壊れる。改行コードのみを対象にした正規表現で分割する。
    """
    if text == "":
        return (), False
    parts = _NEWLINE_RE.split(text)
    final_newline = len(parts) > 1 and parts[-1] == ""
    if final_newline:
        parts.pop()
    return tuple(parts), final_newline


def load(path: Path) -> TextFile | None:
    """テキストとして読む。バイナリ、または復号不能なら None。"""
    data = winpath.extend(path).read_bytes()
    if is_binary(data):
        return None
    decoded = decode(data)
    if decoded is None:
        return None
    text, encoding = decoded
    lines, final_newline = split_lines(text)
    return TextFile(
        lines=lines,
        encoding=encoding,
        newline=detect_newline(text),
        final_newline=final_newline,
    )


def render(tf: TextFile) -> bytes:
    text = tf.newline.join(tf.lines)
    if tf.final_newline and tf.lines:
        text += tf.newline
    return text.encode(tf.encoding)


def save(path: Path, tf: TextFile) -> None:
    winpath.extend(path.parent).mkdir(parents=True, exist_ok=True)
    winpath.extend(path).write_bytes(render(tf))


def describe_newline(newline: str) -> str:
    return {"\r\n": "CRLF", "\n": "LF", "\r": "CR"}.get(newline, repr(newline))

#@@ likegit-bundle @@ likegit/winpath.py @@ 148b23d1b70f56a3c37bed2a3304048dedf2bb3069f0260ed724fa5059c141e9
r"""Windows の 260 文字パス制限を回避する。

退避や出力では、元のパスに `.likegit/snapshots/<名前>/tree/` のような接頭辞が
付く。実測で 44〜77 文字伸びるため、元ファイルは作れていても退避先が 260 文字を
超えて失敗する、ということが階層の深いプロジェクトでは起きる。

制限を外すレジストリ設定 (LongPathsEnabled) は管理者権限が要り、社内 PC では
まず変更できない。一方 `\\?\` 接頭辞は、そのパス 1 つだけ制限を外す。
権限も設定変更も要らないので、こちらを使う。

`\\?\` 付きのパスは OS 側で正規化されないまま渡るため、`..` や `/` を
含んでいてはいけない。`os.path.abspath` がその正規化を担う。

このモジュールは **I/O の直前だけ** で使う。likegit が保持したり
レポートに出したりするパスは接頭辞なしのままにする。
`\\?\C:\...` がエラーメッセージに現れると読み手を混乱させるため。
"""

from __future__ import annotations

import os
from pathlib import Path
from typing import Iterator, Tuple

#: Windows の MAX_PATH。接頭辞なしではこれを超えるパスを扱えない。
MAX_PATH = 260

_PREFIX = "\\\\?\\"
_UNC_PREFIX = "\\\\?\\UNC\\"


def extend(path: Path) -> Path:
    r"""`\\?\` を付けた Path を返す。Windows 以外ではそのまま返す。

    pathlib はこの接頭辞を保持し、mkdir / write_bytes / stat / unlink も
    shutil.copy2 も os.walk も、この形のパスで正しく動く (検証済み)。
    """
    if os.name != "nt":
        return path
    text = os.fspath(path)
    if text.startswith(_PREFIX):
        return path
    absolute = os.path.abspath(text)
    if absolute.startswith("\\\\"):  # UNC (\\server\share)
        return Path(_UNC_PREFIX + absolute[2:])
    return Path(_PREFIX + absolute)


def walk(root: Path) -> Iterator[Tuple[str, list, list]]:
    """os.walk の薄い包み。長いパスでも歩け、返すパスは接頭辞なしに戻す。"""
    plain = os.path.abspath(os.fspath(root))
    prefixed = os.fspath(extend(root))
    cut = len(prefixed) - len(plain)

    for dirpath, dirnames, filenames in os.walk(prefixed, followlinks=False):
        yield (dirpath[cut:] if cut else dirpath), dirnames, filenames


def too_long(path: Path) -> bool:
    """接頭辞なしでは扱えない長さか。警告の要否を判断するのに使う。"""
    return os.name == "nt" and len(os.fspath(path)) >= MAX_PATH

#@@ likegit-bundle @@ tests/test_cli.py @@ 61476307d4f73ea9f841aff6eb5ffaf72cc581d0263f028d4ee95c4ca46d1d56
"""CLI の入口。とくに DESIGN.md §8 の安全性の原則と §9 の終了コード。

「取り消せない書き込みを確認なしに行わない」ことが守られているかは、
実際にコマンドを走らせて確かめるしかないので、ここは統合テストにする。
"""

from __future__ import annotations  # 3.8 でも注釈を評価させない

import io
import os
import tempfile
import unittest
from contextlib import redirect_stderr, redirect_stdout
from pathlib import Path

from likegit import cli, snapshot


class CliCase(unittest.TestCase):
    def setUp(self):
        self._tmp = tempfile.TemporaryDirectory()
        self.root = Path(self._tmp.name)
        self.addCleanup(self._tmp.cleanup)

        self.store = self.root / "store"
        self.mine = self.root / "mine"
        self.theirs = self.root / "theirs"
        for d in (self.mine, self.theirs):
            d.mkdir()

        # 環境変数が漏れると store の場所が変わってしまう
        self._saved_env = os.environ.pop("LIKEGIT_DIR", None)
        self.addCleanup(self._restore_env)

    def _restore_env(self):
        if self._saved_env is not None:
            os.environ["LIKEGIT_DIR"] = self._saved_env
        else:
            os.environ.pop("LIKEGIT_DIR", None)

    def run_cli(self, *argv: str) -> tuple[int, str, str]:
        out, err = io.StringIO(), io.StringIO()
        with redirect_stdout(out), redirect_stderr(err):
            code = cli.main(list(argv))
        return code, out.getvalue(), err.getvalue()

    def put(self, tree: Path, rel: str, text: str) -> Path:
        path = tree / rel
        path.parent.mkdir(parents=True, exist_ok=True)
        path.write_bytes(text.encode("utf-8"))
        return path

    def setup_conflict(self) -> str:
        """base を取り、両者が同じ行を別々に変えた状態を作る。base 名を返す。"""
        self.put(self.mine, "a.py", "one\ntwo\n")
        code, out, _ = self.run_cli(
            "snapshot", str(self.mine), "-m", "渡す前", "--store", str(self.store)
        )
        self.assertEqual(code, cli.EXIT_OK)
        name = snapshot.listing(self.store)[0].name

        self.put(self.theirs, "a.py", "one\nTHEIRS\n")
        self.put(self.mine, "a.py", "one\nMINE\n")
        return name


class TestSnapshot(CliCase):
    def test_snapshot_then_list(self):
        self.put(self.mine, "a.py", "x\n")
        code, _, _ = self.run_cli(
            "snapshot", str(self.mine), "-m", "メモ", "--store", str(self.store)
        )
        self.assertEqual(code, cli.EXIT_OK)

        code, out, _ = self.run_cli("snapshots", "--store", str(self.store))
        self.assertEqual(code, cli.EXIT_OK)
        self.assertIn("メモ", out)

    def test_japanese_message_survives_in_the_name(self):
        self.put(self.mine, "a.py", "x\n")
        self.run_cli(
            "snapshot", str(self.mine), "-m", "Aさんに渡す前", "--store", str(self.store)
        )
        self.assertIn("Aさんに渡す前", snapshot.listing(self.store)[0].name)

    def test_missing_source_is_an_error(self):
        code, _, err = self.run_cli(
            "snapshot", str(self.root / "nope"), "--store", str(self.store)
        )
        self.assertEqual(code, cli.EXIT_ERROR)
        self.assertIn("見つかりません", err)

    def test_snapshot_of_nothing_is_an_error(self):
        """0 件の base は base にならない。黙って成功させると気づけない。"""
        empty = self.root / "empty"
        empty.mkdir()
        code, out, err = self.run_cli(
            "snapshot", str(empty), "--store", str(self.store)
        )
        self.assertEqual(code, cli.EXIT_ERROR)
        self.assertIn("1 件も退避できていません", err)
        # 「--base に指定してください」と案内してはいけない
        self.assertNotIn("統合時は", out)
        # 中身の無い控えを残すと、あとで --base に選べてしまう
        self.assertEqual(snapshot.listing(self.store), [])

    def test_snapshot_of_only_ignored_files_is_an_error(self):
        """除外設定が広すぎて全部弾いた場合も同じ。ここが一番気づきにくい。"""
        src = self.root / "src"
        src.mkdir()
        # 除外設定そのものも弾かないと 1 件残る(それは正しい挙動)
        self.put(src, ".likegitignore", "*.py\n.likegitignore\n")
        self.put(src, "a.py", "x\n")
        self.put(src, "b.py", "y\n")
        code, _, err = self.run_cli(
            "snapshot", str(src), "--store", str(self.store)
        )
        self.assertEqual(code, cli.EXIT_ERROR)
        self.assertIn(".likegitignore", err)

    def test_empty_base_warns_during_merge(self):
        """空の base を掴んだまま統合しようとしたら、レポートで知らせる。"""
        empty_base = self.root / "empty_base"
        empty_base.mkdir()
        self.put(self.mine, "a.py", "one\nMINE\n")
        self.put(self.theirs, "a.py", "one\nTHEIRS\n")

        code, out, _ = self.run_cli(
            "merge", "--base", str(empty_base), "--mine", str(self.mine),
            "--theirs", str(self.theirs), "--out", str(self.root / "out"),
            "--store", str(self.store),
        )
        self.assertEqual(code, cli.EXIT_CONFLICT)
        self.assertIn("1 件もファイルがありません", out)

    def test_empty_listing_is_not_an_error(self):
        code, out, _ = self.run_cli("snapshots", "--store", str(self.store))
        self.assertEqual(code, cli.EXIT_OK)
        self.assertIn("ありません", out)


class TestExitCodes(CliCase):
    def test_clean_merge_returns_zero(self):
        self.put(self.mine, "a.py", "one\ntwo\n")
        self.run_cli("snapshot", str(self.mine), "--store", str(self.store))
        name = snapshot.listing(self.store)[0].name
        self.put(self.theirs, "a.py", "one\nTWO\n")

        code, _, _ = self.run_cli(
            "merge", "--base", name, "--mine", str(self.mine),
            "--theirs", str(self.theirs), "--out", str(self.root / "out"),
            "--store", str(self.store),
        )
        self.assertEqual(code, cli.EXIT_OK)

    def test_conflict_returns_one(self):
        name = self.setup_conflict()
        code, out, _ = self.run_cli(
            "merge", "--base", name, "--mine", str(self.mine),
            "--theirs", str(self.theirs), "--out", str(self.root / "out"),
            "--store", str(self.store),
        )
        self.assertEqual(code, cli.EXIT_CONFLICT)
        self.assertIn("衝突", out)

    def test_bad_arguments_return_two(self):
        code, _, err = self.run_cli(
            "merge", "--mine", str(self.mine), "--theirs", str(self.root / "nope"),
            "--out", str(self.root / "out"),
        )
        self.assertEqual(code, cli.EXIT_ERROR)
        self.assertIn("--theirs", err)


class TestSafety(CliCase):
    """§8 の 5 原則。ここが緩むと取り返しがつかない。"""

    def test_inputs_are_not_modified(self):
        name = self.setup_conflict()
        before = {
            p: (p / "a.py").read_bytes() for p in (self.mine, self.theirs)
        }
        self.run_cli(
            "merge", "--base", name, "--mine", str(self.mine),
            "--theirs", str(self.theirs), "--out", str(self.root / "out"),
            "--store", str(self.store),
        )
        for tree, data in before.items():
            self.assertEqual((tree / "a.py").read_bytes(), data)

    def test_non_empty_out_is_refused(self):
        name = self.setup_conflict()
        out = self.root / "out"
        out.mkdir()
        (out / "existing.txt").write_text("大事なファイル", encoding="utf-8")

        code, _, err = self.run_cli(
            "merge", "--base", name, "--mine", str(self.mine),
            "--theirs", str(self.theirs), "--out", str(out), "--store", str(self.store),
        )
        self.assertEqual(code, cli.EXIT_ERROR)
        self.assertIn("--force", err)
        self.assertTrue((out / "existing.txt").exists())

    def test_force_allows_non_empty_out(self):
        name = self.setup_conflict()
        out = self.root / "out"
        out.mkdir()
        (out / "existing.txt").write_text("x", encoding="utf-8")

        code, _, _ = self.run_cli(
            "merge", "--base", name, "--mine", str(self.mine),
            "--theirs", str(self.theirs), "--out", str(out),
            "--force", "--store", str(self.store),
        )
        self.assertEqual(code, cli.EXIT_CONFLICT)
        self.assertTrue((out / "a.py").exists())

    def test_out_inside_mine_is_refused(self):
        """出力先が入力の中だと、書きながら読む形になり入力を壊す。"""
        name = self.setup_conflict()
        code, _, err = self.run_cli(
            "merge", "--base", name, "--mine", str(self.mine),
            "--theirs", str(self.theirs), "--out", str(self.mine / "out"),
            "--store", str(self.store),
        )
        self.assertEqual(code, cli.EXIT_ERROR)
        self.assertIn("--mine", err)

    def test_out_inside_base_is_refused(self):
        """base は唯一の復旧手段。ここを潰されると 3-way に戻れなくなる。"""
        name = self.setup_conflict()
        base_tree = snapshot.listing(self.store)[0].tree
        code, _, err = self.run_cli(
            "merge", "--base", name, "--mine", str(self.mine),
            "--theirs", str(self.theirs), "--out", str(base_tree / "out"),
            "--store", str(self.store),
        )
        self.assertEqual(code, cli.EXIT_ERROR)
        self.assertIn("base", err)

    def test_nested_inputs_are_refused(self):
        """theirs が mine の中にあると、走査結果が混ざって結果が意味を失う。"""
        nested = self.mine / "from_A"
        nested.mkdir()
        self.put(self.mine, "a.py", "one\n")
        self.put(nested, "a.py", "two\n")
        code, _, err = self.run_cli(
            "merge", "--mine", str(self.mine), "--theirs", str(nested),
            "--out", str(self.root / "out"), "--store", str(self.store),
        )
        self.assertEqual(code, cli.EXIT_ERROR)
        self.assertIn("入れ子", err)

    def test_identical_mine_and_theirs_paths_are_refused(self):
        self.put(self.mine, "a.py", "one\n")
        code, _, err = self.run_cli(
            "merge", "--mine", str(self.mine), "--theirs", str(self.mine),
            "--out", str(self.root / "out"), "--store", str(self.store),
        )
        self.assertEqual(code, cli.EXIT_ERROR)
        self.assertIn("同じ場所", err)

    def test_default_store_inside_mine_is_allowed(self):
        """--mine . のとき既定の store は mine の中に入る。scanner が除外するので実害はない。"""
        store = self.mine / ".likegit"
        self.put(self.mine, "a.py", "one\ntwo\nthree\n")
        self.run_cli("snapshot", str(self.mine), "--store", str(store))
        name = snapshot.listing(store)[0].name

        self.put(self.mine, "a.py", "ONE\ntwo\nthree\n")
        self.put(self.theirs, "a.py", "one\ntwo\nTHREE\n")
        code, _, err = self.run_cli(
            "merge", "--base", name, "--mine", str(self.mine),
            "--theirs", str(self.theirs), "--out", str(self.root / "out"),
            "--store", str(store),
        )
        self.assertEqual(code, cli.EXIT_OK, err)
        self.assertEqual(
            (self.root / "out" / "a.py").read_text(encoding="utf-8"), "ONE\ntwo\nTHREE\n"
        )
        self.assertFalse((self.root / "out" / ".likegit").exists())

    def test_dry_run_writes_nothing(self):
        name = self.setup_conflict()
        out = self.root / "out"
        code, stdout, _ = self.run_cli(
            "merge", "--base", name, "--mine", str(self.mine),
            "--theirs", str(self.theirs), "--out", str(out),
            "--dry-run", "--store", str(self.store),
        )
        self.assertEqual(code, cli.EXIT_CONFLICT)
        self.assertFalse(out.exists())
        self.assertIn("dry-run", stdout)
        # レポートも残さない
        self.assertFalse((self.store / snapshot.REPORTS).exists())

    def test_dry_run_needs_no_destination(self):
        name = self.setup_conflict()
        code, _, _ = self.run_cli(
            "merge", "--base", name, "--mine", str(self.mine),
            "--theirs", str(self.theirs), "--dry-run", "--store", str(self.store),
        )
        self.assertEqual(code, cli.EXIT_CONFLICT)

    def test_missing_destination_is_refused(self):
        name = self.setup_conflict()
        code, _, err = self.run_cli(
            "merge", "--base", name, "--mine", str(self.mine),
            "--theirs", str(self.theirs), "--store", str(self.store),
        )
        self.assertEqual(code, cli.EXIT_ERROR)
        self.assertIn("出力先", err)

    def test_out_and_in_place_are_exclusive(self):
        name = self.setup_conflict()
        code, _, err = self.run_cli(
            "merge", "--base", name, "--mine", str(self.mine),
            "--theirs", str(self.theirs), "--out", str(self.root / "out"),
            "--in-place", "--store", str(self.store),
        )
        self.assertEqual(code, cli.EXIT_ERROR)
        self.assertIn("同時", err)

    def test_in_place_takes_a_backup_first(self):
        name = self.setup_conflict()
        before = (self.mine / "a.py").read_bytes()

        code, out, _ = self.run_cli(
            "merge", "--base", name, "--mine", str(self.mine),
            "--theirs", str(self.theirs), "--in-place", "--store", str(self.store),
        )
        self.assertEqual(code, cli.EXIT_CONFLICT)
        # mine は書き換わっている
        self.assertIn(b"<<<<<<<", (self.mine / "a.py").read_bytes())
        # 直前の状態がバックアップから戻せる
        backups = snapshot.listing(self.store, snapshot.BACKUPS)
        self.assertEqual(len(backups), 1)
        self.assertEqual((backups[0].tree / "a.py").read_bytes(), before)
        self.assertIn("backup", out)


class TestMergeBehaviour(CliCase):
    def test_two_way_without_base_warns(self):
        self.put(self.mine, "a.py", "one\nMINE\n")
        self.put(self.theirs, "a.py", "one\nTHEIRS\n")
        code, out, _ = self.run_cli(
            "merge", "--mine", str(self.mine), "--theirs", str(self.theirs),
            "--out", str(self.root / "out"), "--store", str(self.store),
        )
        self.assertEqual(code, cli.EXIT_CONFLICT)
        self.assertIn("2-way", out)

    def test_prefer_mine_avoids_conflict(self):
        name = self.setup_conflict()
        out = self.root / "out"
        code, _, _ = self.run_cli(
            "merge", "--base", name, "--mine", str(self.mine),
            "--theirs", str(self.theirs), "--out", str(out),
            "--prefer", "mine", "--store", str(self.store),
        )
        self.assertEqual(code, cli.EXIT_OK)
        self.assertEqual((out / "a.py").read_text(encoding="utf-8"), "one\nMINE\n")

    def test_diff3_includes_base(self):
        name = self.setup_conflict()
        out = self.root / "out"
        self.run_cli(
            "merge", "--base", name, "--mine", str(self.mine),
            "--theirs", str(self.theirs), "--out", str(out),
            "--diff3", "--store", str(self.store),
        )
        text = (out / "a.py").read_text(encoding="utf-8")
        self.assertIn("||||||| BASE", text)
        self.assertIn("two", text)

    def test_custom_labels(self):
        name = self.setup_conflict()
        out = self.root / "out"
        self.run_cli(
            "merge", "--base", name, "--mine", str(self.mine),
            "--theirs", str(self.theirs), "--out", str(out),
            "--label-mine", "自分", "--label-theirs", "Aさん", "--store", str(self.store),
        )
        text = (out / "a.py").read_text(encoding="utf-8")
        self.assertIn("<<<<<<< 自分", text)
        self.assertIn(">>>>>>> Aさん", text)

    def test_base_can_be_a_plain_directory(self):
        """スナップショットを取り損ねても、当時のフォルダが残っていれば base に使える。

        変更どうしの間に無変更の行が要る。隣り合った変更は同期点が取れず
        1 つの不安定区間になるため衝突になる (git merge-file と同じ挙動)。
        """
        base_dir = self.root / "base_dir"
        base_dir.mkdir()
        self.put(base_dir, "a.py", "one\ntwo\nthree\n")
        self.put(self.mine, "a.py", "ONE\ntwo\nthree\n")
        self.put(self.theirs, "a.py", "one\ntwo\nTHREE\n")

        code, _, _ = self.run_cli(
            "merge", "--base", str(base_dir), "--mine", str(self.mine),
            "--theirs", str(self.theirs), "--out", str(self.root / "out"),
            "--store", str(self.store),
        )
        self.assertEqual(code, cli.EXIT_OK)
        self.assertEqual(
            (self.root / "out" / "a.py").read_text(encoding="utf-8"), "ONE\ntwo\nTHREE\n"
        )

    def test_unknown_base_is_an_error(self):
        self.put(self.mine, "a.py", "x\n")
        self.put(self.theirs, "a.py", "y\n")
        code, _, err = self.run_cli(
            "merge", "--base", "存在しない名前", "--mine", str(self.mine),
            "--theirs", str(self.theirs), "--out", str(self.root / "out"),
            "--store", str(self.store),
        )
        self.assertEqual(code, cli.EXIT_ERROR)
        self.assertIn("base が見つかりません", err)

    def test_report_is_saved(self):
        name = self.setup_conflict()
        self.run_cli(
            "merge", "--base", name, "--mine", str(self.mine),
            "--theirs", str(self.theirs), "--out", str(self.root / "out"),
            "--store", str(self.store),
        )
        reports = list((self.store / snapshot.REPORTS).glob("*_merge.txt"))
        self.assertEqual(len(reports), 1)
        self.assertIn("衝突", reports[0].read_text(encoding="utf-8"))


class TestFileMode(CliCase):
    def _three_files(self) -> tuple[Path, Path, Path]:
        base_file = self.root / "base.py"
        base_file.write_bytes(b"one\ntwo\nthree\n")
        mine_file = self.mine / "a.py"
        mine_file.write_bytes(b"ONE\ntwo\nthree\n")
        theirs_file = self.theirs / "a.py"
        theirs_file.write_bytes(b"one\ntwo\nTHREE\n")
        return base_file, mine_file, theirs_file

    def test_merging_two_files(self):
        base_file, mine_file, theirs_file = self._three_files()
        out_file = self.root / "merged.py"
        code, _, _ = self.run_cli(
            "merge", "--base", str(base_file), "--mine", str(mine_file),
            "--theirs", str(theirs_file), "--out", str(out_file),
            "--store", str(self.store),
        )
        self.assertEqual(code, cli.EXIT_OK)
        self.assertEqual(out_file.read_text(encoding="utf-8"), "ONE\ntwo\nTHREE\n")

    def test_directory_base_with_file_inputs_is_refused(self):
        _base, mine_file, theirs_file = self._three_files()
        code, _, err = self.run_cli(
            "merge", "--base", str(self.root), "--mine", str(mine_file),
            "--theirs", str(theirs_file), "--out", str(self.root / "merged.py"),
            "--store", str(self.store),
        )
        self.assertEqual(code, cli.EXIT_ERROR)
        self.assertIn("ファイル", err)

    def test_existing_out_file_is_refused(self):
        mine_file = self.mine / "a.py"
        mine_file.write_text("a\n", encoding="utf-8")
        theirs_file = self.theirs / "a.py"
        theirs_file.write_text("b\n", encoding="utf-8")
        out_file = self.root / "merged.py"
        out_file.write_text("大事", encoding="utf-8")

        code, _, err = self.run_cli(
            "merge", "--mine", str(mine_file), "--theirs", str(theirs_file),
            "--out", str(out_file), "--store", str(self.store),
        )
        self.assertEqual(code, cli.EXIT_ERROR)
        self.assertIn("--force", err)
        self.assertEqual(out_file.read_text(encoding="utf-8"), "大事")

    def test_file_and_directory_cannot_be_mixed(self):
        mine_file = self.mine / "a.py"
        mine_file.write_text("a\n", encoding="utf-8")
        code, _, err = self.run_cli(
            "merge", "--mine", str(mine_file), "--theirs", str(self.theirs),
            "--out", str(self.root / "out"), "--store", str(self.store),
        )
        self.assertEqual(code, cli.EXIT_ERROR)
        self.assertIn("両方", err)

    def test_in_place_on_a_single_file(self):
        base_file, mine_file, theirs_file = self._three_files()
        sibling = self.mine / "empty_dir"
        sibling.mkdir()

        code, _, _ = self.run_cli(
            "merge", "--base", str(base_file), "--mine", str(mine_file),
            "--theirs", str(theirs_file), "--in-place", "--store", str(self.store),
        )
        self.assertEqual(code, cli.EXIT_OK)
        self.assertEqual(mine_file.read_text(encoding="utf-8"), "ONE\ntwo\nTHREE\n")
        backups = snapshot.listing(self.store, snapshot.BACKUPS)
        self.assertEqual(
            (backups[0].tree / "a.py").read_text(encoding="utf-8"), "ONE\ntwo\nthree\n"
        )
        # 親ディレクトリは自分の管理下ではない。無関係な空フォルダを消さないこと。
        self.assertTrue(sibling.is_dir())


class TestIgnore(CliCase):
    def test_default_ignores_are_skipped(self):
        self.put(self.mine, "__pycache__/x.pyc", "junk")
        self.put(self.mine, "a.py", "one\n")
        self.put(self.theirs, "a.py", "one\n")
        out = self.root / "out"
        self.run_cli(
            "merge", "--mine", str(self.mine), "--theirs", str(self.theirs),
            "--out", str(out), "--store", str(self.store),
        )
        self.assertFalse((out / "__pycache__").exists())

    def test_likegitignore_is_honoured(self):
        self.put(self.mine, ".likegitignore", "*.log\nbuild/\n")
        self.put(self.mine, "debug.log", "noise")
        self.put(self.mine, "build/out.txt", "noise")
        self.put(self.mine, "a.py", "one\n")
        self.put(self.theirs, "a.py", "one\n")
        out = self.root / "out"
        self.run_cli(
            "merge", "--mine", str(self.mine), "--theirs", str(self.theirs),
            "--out", str(out), "--store", str(self.store),
        )
        self.assertFalse((out / "debug.log").exists())
        self.assertFalse((out / "build").exists())
        self.assertTrue((out / "a.py").exists())


if __name__ == "__main__":
    unittest.main()

#@@ likegit-bundle @@ tests/test_diff3.py @@ e547bba97531debaedbad14f654c456429349c0bbfede0a80a5ad900a0ec0372
"""マージ中核の検証。純粋関数なので、行の配列を直接与えて確かめる。"""

from __future__ import annotations  # 3.8 でも注釈を評価させない

import unittest

from likegit import diff3


def lines(text: str) -> list[str]:
    """見やすいリテラルを行の配列にする。空文字は空の配列 (= base 無し)。"""
    text = text.strip("\n")
    return text.split("\n") if text else []


def merged(base: str, mine: str, theirs: str, show_base: bool = False) -> list[str]:
    regions = diff3.merge3(lines(base), lines(mine), lines(theirs))
    return diff3.render(regions, show_base=show_base)


def conflicts(base: str, mine: str, theirs: str) -> int:
    return diff3.count_conflicts(diff3.merge3(lines(base), lines(mine), lines(theirs)))


class TestAutoResolution(unittest.TestCase):
    def test_untouched_stays(self):
        text = "a\nb\nc"
        self.assertEqual(merged(text, text, text), lines(text))
        self.assertEqual(conflicts(text, text, text), 0)

    def test_only_mine_changed(self):
        result = merged("a\nb\nc", "a\nB\nc", "a\nb\nc")
        self.assertEqual(result, ["a", "B", "c"])

    def test_only_theirs_changed(self):
        result = merged("a\nb\nc", "a\nb\nc", "a\nB\nc")
        self.assertEqual(result, ["a", "B", "c"])

    def test_disjoint_changes_both_kept(self):
        """離れた場所への変更は両方取り込む。3-way の本領。"""
        result = merged("a\nb\nc\nd\ne", "A\nb\nc\nd\ne", "a\nb\nc\nd\nE")
        self.assertEqual(result, ["A", "b", "c", "d", "E"])

    def test_same_change_on_both_sides(self):
        result = merged("a\nb\nc", "a\nX\nc", "a\nX\nc")
        self.assertEqual(result, ["a", "X", "c"])
        self.assertEqual(conflicts("a\nb\nc", "a\nX\nc", "a\nX\nc"), 0)

    def test_insertion_by_theirs(self):
        result = merged("a\nc", "a\nc", "a\nb\nc")
        self.assertEqual(result, ["a", "b", "c"])

    def test_deletion_by_mine(self):
        result = merged("a\nb\nc", "a\nc", "a\nb\nc")
        self.assertEqual(result, ["a", "c"])

    def test_empty_base_with_identical_sides(self):
        """base が無くても、両者が同一なら衝突にはならない。"""
        self.assertEqual(conflicts("", "a\nb", "a\nb"), 0)


class TestConflicts(unittest.TestCase):
    def test_same_line_changed_differently(self):
        result = merged("a\nb\nc", "a\nX\nc", "a\nY\nc")
        self.assertEqual(
            result,
            ["a", "<<<<<<< MINE", "X", "=======", "Y", ">>>>>>> THEIRS", "c"],
        )

    def test_conflict_is_minimized(self):
        """衝突の外に出せる一致行は外に出す。読む量を減らすため。"""
        result = merged("", "head\nX\ntail", "head\nY\ntail")
        self.assertEqual(
            result,
            ["head", "<<<<<<< MINE", "X", "=======", "Y", ">>>>>>> THEIRS", "tail"],
        )

    def test_minimization_stops_where_base_disagrees(self):
        """base が食い違う位置では最小化を打ち切る (DESIGN.md §5)。

        mine と theirs の末尾 "keep" は一致しているが、base の同位置は
        "three" なので外へ出さない。出してしまうと --diff3 の BASE
        セクションだけ行数がずれ、読み手に誤った対応関係を見せる。
        衝突が少し大きくなるのはその代償。
        """
        result = merged(
            "one\ntwo\nthree\nfour",
            "one\nMINE\nkeep\nfour",
            "one\nTHEIRS\nkeep\nfour",
        )
        self.assertEqual(
            result,
            [
                "one",
                "<<<<<<< MINE",
                "MINE",
                "keep",
                "=======",
                "THEIRS",
                "keep",
                ">>>>>>> THEIRS",
                "four",
            ],
        )

    def test_diff3_shows_base(self):
        result = merged("a\nb\nc", "a\nX\nc", "a\nY\nc", show_base=True)
        self.assertEqual(
            result,
            [
                "a",
                "<<<<<<< MINE",
                "X",
                "||||||| BASE",
                "b",
                "=======",
                "Y",
                ">>>>>>> THEIRS",
                "c",
            ],
        )

    def test_two_way_marks_every_difference(self):
        """base が無ければ、どちらが変更側か判別できないので衝突にする。"""
        self.assertEqual(conflicts("", "a\nX", "a\nY"), 1)

    def test_conflict_line_numbers_match_render(self):
        for show_base in (False, True):
            with self.subTest(show_base=show_base):
                regions = diff3.merge3(
                    lines("a\nb\nc\nd\ne\nf"),
                    lines("a\nX\nc\nd\nP\nf"),
                    lines("a\nY\nc\nd\nQ\nf"),
                )
                out = diff3.render(regions, show_base=show_base)
                found = list(diff3.iter_conflicts(regions, show_base=show_base))
                self.assertEqual(len(found), 2)
                for line_no, _conflict in found:
                    # 1 始まりの行番号がマーカー行を指しているか
                    self.assertTrue(out[line_no - 1].startswith(diff3.MARK_MINE))


class TestAutojunk(unittest.TestCase):
    def test_repeated_blank_lines_do_not_break_diff(self):
        """空行や "}" が多いコードでも差分が劣化しないこと (autojunk=False)。

        既定の autojunk は要素数 200 超で頻出要素をノイズ扱いするため、
        この規模でないと再現しない。
        """
        block = ["", "}"] * 150
        base = ["header"] + block + ["tail"]
        mine = ["header"] + block + ["tail-mine"]
        theirs = ["HEADER"] + block + ["tail"]

        result = diff3.render(diff3.merge3(base, mine, theirs))
        self.assertEqual(result[0], "HEADER")
        self.assertEqual(result[-1], "tail-mine")
        self.assertEqual(diff3.count_conflicts(diff3.merge3(base, mine, theirs)), 0)


class TestMarkerDetection(unittest.TestCase):
    def test_detects_existing_markers(self):
        self.assertTrue(diff3.has_marker(["ok", "<<<<<<< MINE", "x"]))
        self.assertTrue(diff3.has_marker(["=======" ]))
        self.assertFalse(diff3.has_marker(["a", "b", "== not a marker"]))


if __name__ == "__main__":
    unittest.main()

#@@ likegit-bundle @@ tests/test_merger.py @@ 05135b7492a3634a0b0fa6b0c8ca98b1e7bf3788b4a72c417a36b905fea19456
"""ツリー単位の判定 (DESIGN.md §7) と、計画/実行の分離。"""

from __future__ import annotations  # 3.8 でも注釈を評価させない

import tempfile
import unittest
from pathlib import Path

from likegit import merger, textio


class TreeCase(unittest.TestCase):
    def setUp(self):
        self._tmp = tempfile.TemporaryDirectory()
        self.root = Path(self._tmp.name)
        self.addCleanup(self._tmp.cleanup)
        self.base = self.root / "base"
        self.mine = self.root / "mine"
        self.theirs = self.root / "theirs"
        for d in (self.base, self.mine, self.theirs):
            d.mkdir()

    def put(self, tree: Path, rel: str, text: str, newline: str = "\n") -> Path:
        path = tree / rel
        path.parent.mkdir(parents=True, exist_ok=True)
        path.write_bytes(text.replace("\n", newline).encode("utf-8"))
        return path

    def put_bytes(self, tree: Path, rel: str, data: bytes) -> Path:
        path = tree / rel
        path.parent.mkdir(parents=True, exist_ok=True)
        path.write_bytes(data)
        return path

    def plan(self, with_base: bool = True, **kwargs) -> merger.Plan:
        options = kwargs.pop("options", merger.Options())
        return merger.plan_tree(
            self.base if with_base else None, self.mine, self.theirs, options, **kwargs
        )

    def outcome(self, plan: merger.Plan, rel: str) -> merger.Outcome:
        for o in plan.outcomes:
            if o.path == rel:
                return o
        self.fail(f"{rel} が計画にありません: {[o.path for o in plan.outcomes]}")


class TestTreeMatrix(TreeCase):
    """DESIGN.md §7 の表を 1 行ずつ確かめる。"""

    def test_theirs_only_is_added(self):
        self.put(self.theirs, "new.py", "x\n")
        self.assertEqual(
            self.outcome(self.plan(), "new.py").action, merger.ACTION_ADDED_THEIRS
        )

    def test_mine_only_is_kept(self):
        self.put(self.mine, "new.py", "x\n")
        self.assertEqual(
            self.outcome(self.plan(), "new.py").action, merger.ACTION_ADDED_MINE
        )

    def test_both_added_same_content(self):
        self.put(self.mine, "new.py", "x\n")
        self.put(self.theirs, "new.py", "x\n")
        self.assertEqual(
            self.outcome(self.plan(), "new.py").action, merger.ACTION_ADDED_BOTH
        )

    def test_both_made_the_same_change(self):
        """内容は決まるが「変更なし」ではない。受領内容を確かめる人のために区別する。"""
        self.put(self.base, "a.py", "one\n")
        self.put(self.mine, "a.py", "TWO\n")
        self.put(self.theirs, "a.py", "TWO\n")
        self.assertEqual(
            self.outcome(self.plan(), "a.py").action, merger.ACTION_SAME_CHANGE
        )

    def test_untouched_by_both_is_unchanged(self):
        self.put(self.base, "a.py", "one\n")
        self.put(self.mine, "a.py", "one\n")
        self.put(self.theirs, "a.py", "one\n")
        self.assertEqual(
            self.outcome(self.plan(), "a.py").action, merger.ACTION_UNCHANGED
        )

    def test_both_added_different_content_conflicts(self):
        """base が無いので、どちらが正しいか原理的に決められない。"""
        self.put(self.mine, "new.py", "x\n")
        self.put(self.theirs, "new.py", "y\n")
        self.assertTrue(self.outcome(self.plan(), "new.py").is_conflict)

    def test_three_way_merge(self):
        self.put(self.base, "a.py", "one\ntwo\nthree\n")
        self.put(self.mine, "a.py", "ONE\ntwo\nthree\n")
        self.put(self.theirs, "a.py", "one\ntwo\nTHREE\n")
        outcome = self.outcome(self.plan(), "a.py")
        self.assertEqual(outcome.action, merger.ACTION_AUTO)
        self.assertEqual(outcome.conflicts, 0)

    def test_theirs_deleted_mine_untouched(self):
        self.put(self.base, "gone.py", "x\n")
        self.put(self.mine, "gone.py", "x\n")
        outcome = self.outcome(self.plan(), "gone.py")
        self.assertEqual(outcome.action, merger.ACTION_DELETED)
        self.assertTrue(outcome.delete)

    def test_theirs_deleted_mine_modified_conflicts(self):
        self.put(self.base, "x.py", "x\n")
        self.put(self.mine, "x.py", "changed\n")
        outcome = self.outcome(self.plan(), "x.py")
        self.assertEqual(outcome.action, merger.ACTION_DELETE_CONFLICT)
        # 変更が入っている側を残す
        self.assertEqual(outcome.writes[0].src, self.mine / "x.py")

    def test_mine_deleted_theirs_modified_conflicts(self):
        self.put(self.base, "x.py", "x\n")
        self.put(self.theirs, "x.py", "changed\n")
        outcome = self.outcome(self.plan(), "x.py")
        self.assertEqual(outcome.action, merger.ACTION_DELETE_CONFLICT)
        self.assertEqual(outcome.writes[0].src, self.theirs / "x.py")

    def test_both_deleted(self):
        self.put(self.base, "x.py", "x\n")
        outcome = self.outcome(self.plan(), "x.py")
        self.assertEqual(outcome.action, merger.ACTION_DELETED)
        self.assertTrue(outcome.delete)


class TestBinary(TreeCase):
    def test_only_theirs_changed_takes_theirs(self):
        self.put_bytes(self.base, "d.bin", bytes([0, 1]))
        self.put_bytes(self.mine, "d.bin", bytes([0, 1]))
        self.put_bytes(self.theirs, "d.bin", bytes([0, 2]))
        self.assertEqual(
            self.outcome(self.plan(), "d.bin").action, merger.ACTION_THEIRS
        )

    def test_both_changed_keeps_mine_and_writes_sidecar(self):
        self.put_bytes(self.base, "d.bin", bytes([0, 1]))
        self.put_bytes(self.mine, "d.bin", bytes([0, 9]))
        self.put_bytes(self.theirs, "d.bin", bytes([0, 7]))
        outcome = self.outcome(self.plan(), "d.bin")
        self.assertEqual(outcome.action, merger.ACTION_BINARY_CONFLICT)
        rels = [w.rel for w in outcome.writes]
        self.assertEqual(rels, ["d.bin", "d.THEIRS.bin"])

    def test_sidecar_name_without_suffix(self):
        self.assertEqual(merger._sidecar("Makefile", "THEIRS"), "Makefile.THEIRS")
        self.assertEqual(merger._sidecar("a/b.xlsx", "THEIRS"), "a/b.THEIRS.xlsx")


class TestFormatPreservation(TreeCase):
    def test_crlf_only_difference_is_not_a_conflict(self):
        """改行コードだけが違うファイルを差分にしない。実務で最も多い事故。"""
        self.put(self.base, "a.py", "one\ntwo\n", newline="\n")
        self.put(self.mine, "a.py", "one\ntwo\n", newline="\r\n")
        self.put(self.theirs, "a.py", "one\ntwo\n", newline="\n")
        outcome = self.outcome(self.plan(), "a.py")
        self.assertEqual(outcome.conflicts, 0)

    def test_output_keeps_mine_newline(self):
        """相手が LF でも、自分が CRLF なら CRLF で書き戻す。"""
        self.put(self.base, "a.py", "one\ntwo\nthree\n", newline="\r\n")
        self.put(self.mine, "a.py", "ONE\ntwo\nthree\n", newline="\r\n")
        self.put(self.theirs, "a.py", "one\ntwo\nTHREE\n", newline="\n")
        plan = self.plan()
        self.assertEqual(self.outcome(plan, "a.py").conflicts, 0)

        out = self.root / "out"
        merger.apply(plan, out)
        data = (out / "a.py").read_bytes()
        self.assertEqual(data, "ONE\r\ntwo\r\nTHREE\r\n".encode("utf-8"))
        # 裸の LF が 1 つも混ざっていないこと
        self.assertEqual(data.count(b"\n"), data.count(b"\r\n"))

    def test_encoding_mismatch_is_reported(self):
        (self.base / "a.py").write_bytes("あ\nい\n".encode("utf-8"))
        (self.mine / "a.py").write_bytes("あ\nイ\n".encode("utf-8"))
        (self.theirs / "a.py").write_bytes("ア\nい\n".encode("cp932"))
        outcome = self.outcome(self.plan(), "a.py")
        self.assertTrue(any("文字コード相違" in n for n in outcome.notes))
        # mine 優先で保存される
        merger.apply(self.plan(), self.root / "out")
        self.assertEqual(textio.load(self.root / "out" / "a.py").encoding, "utf-8")


class TestApply(TreeCase):
    def test_dry_run_equivalent_plan_writes_nothing_until_applied(self):
        """計画を作るだけでは 1 バイトも書かない。--dry-run が成立する根拠。"""
        self.put(self.base, "a.py", "x\n")
        self.put(self.mine, "a.py", "y\n")
        self.put(self.theirs, "a.py", "z\n")
        out = self.root / "out"
        self.plan()
        self.assertFalse(out.exists())

    def test_inputs_are_never_modified(self):
        self.put(self.base, "a.py", "one\n")
        self.put(self.mine, "a.py", "mine\n")
        self.put(self.theirs, "a.py", "theirs\n")
        before = {
            p: (p / "a.py").read_bytes() for p in (self.base, self.mine, self.theirs)
        }
        merger.apply(self.plan(), self.root / "out")
        for tree, data in before.items():
            self.assertEqual((tree / "a.py").read_bytes(), data)

    def test_in_place_keeps_directories_that_were_already_empty(self):
        """元から空だったフォルダを巻き込まない。

        置き場所として用意した logs/ のようなフォルダを黙って消すと、
        「なぜか動かない」形で後から効いてくる。
        """
        self.put(self.mine, "a.py", "x\n")
        self.put(self.theirs, "a.py", "x\n")
        self.put(self.base, "a.py", "x\n")
        (self.mine / "logs").mkdir()
        merger.apply(self.plan(), self.mine, in_place=True)
        self.assertTrue((self.mine / "logs").is_dir())

    def test_in_place_removes_deleted_files_and_empty_dirs(self):
        self.put(self.base, "sub/gone.py", "x\n")
        self.put(self.mine, "sub/gone.py", "x\n")
        self.put(self.mine, "keep.py", "k\n")
        self.put(self.theirs, "keep.py", "k\n")
        merger.apply(self.plan(), self.mine, in_place=True)
        self.assertFalse((self.mine / "sub" / "gone.py").exists())
        self.assertFalse((self.mine / "sub").exists())
        self.assertTrue((self.mine / "keep.py").exists())

    def test_in_place_binary_conflict_does_not_copy_onto_itself(self):
        """mine 側を残すバイナリ衝突では src と書き込み先が同一になる。

        Windows の CopyFile2 は自分自身へのコピーを「使用中」エラーにするため、
        ここを弾かないと --in-place が途中で死ぬ。
        """
        self.put_bytes(self.base, "d.bin", bytes([0, 1]))
        self.put_bytes(self.mine, "d.bin", bytes([0, 9]))
        self.put_bytes(self.theirs, "d.bin", bytes([0, 7]))
        merger.apply(self.plan(), self.mine, in_place=True)
        self.assertEqual((self.mine / "d.bin").read_bytes(), bytes([0, 9]))
        self.assertEqual((self.mine / "d.THEIRS.bin").read_bytes(), bytes([0, 7]))

    def test_in_place_leaves_unchanged_files_alone(self):
        """変更のないファイルの mtime を壊さない。ビルドの再実行を誘発しないため。"""
        path = self.put(self.mine, "a.py", "same\n")
        self.put(self.base, "a.py", "same\n")
        self.put(self.theirs, "a.py", "same\n")
        import os

        os.utime(path, (1000000, 1000000))
        merger.apply(self.plan(), self.mine, in_place=True)
        self.assertEqual(int(path.stat().st_mtime), 1000000)


class TestPrefer(TreeCase):
    def test_prefer_mine_resolves_conflicts(self):
        self.put(self.base, "a.py", "one\n")
        self.put(self.mine, "a.py", "MINE\n")
        self.put(self.theirs, "a.py", "THEIRS\n")
        options = merger.Options(prefer="mine")
        plan = self.plan(options=options)
        outcome = self.outcome(plan, "a.py")
        self.assertEqual(outcome.conflicts, 0)
        self.assertFalse(outcome.is_conflict)
        merger.apply(plan, self.root / "out")
        self.assertEqual((self.root / "out" / "a.py").read_bytes(), b"MINE\n")

    def test_prefer_theirs_resolves_conflicts(self):
        self.put(self.base, "a.py", "one\n")
        self.put(self.mine, "a.py", "MINE\n")
        self.put(self.theirs, "a.py", "THEIRS\n")
        plan = self.plan(options=merger.Options(prefer="theirs"))
        merger.apply(plan, self.root / "out")
        self.assertEqual((self.root / "out" / "a.py").read_bytes(), b"THEIRS\n")


class TestConflictLines(TreeCase):
    def test_line_numbers_point_at_markers(self):
        self.put(self.base, "a.py", "1\n2\n3\n4\n5\n")
        self.put(self.mine, "a.py", "1\nM\n3\n4\nM2\n")
        self.put(self.theirs, "a.py", "1\nT\n3\n4\nT2\n")
        plan = self.plan()
        outcome = self.outcome(plan, "a.py")
        merger.apply(plan, self.root / "out")
        lines = (self.root / "out" / "a.py").read_text(encoding="utf-8").split("\n")
        self.assertEqual(len(outcome.conflict_lines), 2)
        for line_no in outcome.conflict_lines:
            self.assertTrue(lines[line_no - 1].startswith("<<<<<<<"))


class TestNoBase(TreeCase):
    def test_two_way_warns(self):
        self.put(self.mine, "a.py", "x\n")
        self.put(self.theirs, "a.py", "x\n")
        plan = self.plan(with_base=False)
        self.assertFalse(plan.has_base)
        self.assertTrue(plan.warnings)

    def test_two_way_mine_only_file_is_kept(self):
        self.put(self.mine, "a.py", "x\n")
        outcome = self.outcome(self.plan(with_base=False), "a.py")
        self.assertEqual(outcome.action, merger.ACTION_MINE)


if __name__ == "__main__":
    unittest.main()

#@@ likegit-bundle @@ tests/test_textio.py @@ 524c83efd14b6b75a7c8e846be099f66ed588b476c024d155740323caa3d0046
"""エンコーディングと改行コードの検出・復元。

このツールで最も高頻度の事故は「1 行も変えていないのにファイル全体が
差分になる」で、原因は CRLF/LF と UTF-8/CP932 の混在。ここが崩れると
マージ結果は正しくても実務では使えないので、往復で厚く確かめる。
"""

from __future__ import annotations  # 3.8 でも注釈を評価させない

import tempfile
import unittest
from pathlib import Path

from likegit import textio


class TempDirCase(unittest.TestCase):
    def setUp(self):
        self._tmp = tempfile.TemporaryDirectory()
        self.root = Path(self._tmp.name)
        self.addCleanup(self._tmp.cleanup)

    def write(self, name: str, data: bytes) -> Path:
        path = self.root / name
        path.write_bytes(data)
        return path


class TestDetection(TempDirCase):
    def test_utf8_without_bom_stays_without_bom(self):
        """utf-8-sig を候補に混ぜると、ここで BOM が足されてしまう。"""
        path = self.write("a.txt", "あい\nうえ\n".encode("utf-8"))
        tf = textio.load(path)
        self.assertEqual(tf.encoding, "utf-8")
        self.assertEqual(textio.render(tf), "あい\nうえ\n".encode("utf-8"))

    def test_utf8_with_bom_keeps_bom(self):
        path = self.write("b.txt", "あい\n".encode("utf-8-sig"))
        tf = textio.load(path)
        self.assertEqual(tf.encoding, "utf-8-sig")
        self.assertEqual(textio.render(tf)[:3], b"\xef\xbb\xbf")

    def test_cp932_is_detected(self):
        path = self.write("c.txt", "日本語のテキスト\n".encode("cp932"))
        tf = textio.load(path)
        self.assertEqual(tf.encoding, "cp932")
        self.assertEqual(tf.lines, ("日本語のテキスト",))

    def test_utf8_wins_over_cp932(self):
        """候補順の要。逆順だと UTF-8 の日本語が化けたまま「読めた」ことになる。"""
        path = self.write("d.txt", "日本語\n".encode("utf-8"))
        self.assertEqual(textio.load(path).encoding, "utf-8")

    def test_binary_returns_none(self):
        path = self.write("e.bin", bytes([0, 1, 2, 3]))
        self.assertIsNone(textio.load(path))

    def test_newline_detection(self):
        self.assertEqual(textio.detect_newline("a\r\nb\r\n"), "\r\n")
        self.assertEqual(textio.detect_newline("a\nb\n"), "\n")
        self.assertEqual(textio.detect_newline("a\rb\r"), "\r")
        self.assertEqual(textio.detect_newline("no newline"), "\n")

    def test_mixed_newlines_take_the_majority(self):
        self.assertEqual(textio.detect_newline("a\r\nb\r\nc\n"), "\r\n")


class TestRoundTrip(TempDirCase):
    """読んで書き戻すだけならバイト単位で元に戻ること。"""

    SAMPLES = {
        "utf8-lf": "a\nb\n".encode("utf-8"),
        "utf8-crlf": "a\r\nb\r\n".encode("utf-8"),
        "utf8-bom-crlf": "あ\r\nい\r\n".encode("utf-8-sig"),
        "cp932-crlf": "あ\r\nい\r\n".encode("cp932"),
        "no-final-newline": b"a\r\nb",
        "empty": b"",
        "single-line": b"only",
        "blank-lines": b"a\n\n\nb\n",
    }

    def test_round_trip_is_byte_identical(self):
        for name, data in self.SAMPLES.items():
            with self.subTest(name=name):
                path = self.write(name, data)
                tf = textio.load(path)
                self.assertIsNotNone(tf)
                self.assertEqual(textio.render(tf), data)


class TestSplitLines(unittest.TestCase):
    def test_does_not_split_on_vertical_tab(self):
        """str.splitlines() は \\x0b でも切ってしまい、繋ぎ直すとファイルが壊れる。"""
        parts, final = textio.split_lines("a\x0bb\nc\n")
        self.assertEqual(parts, ("a\x0bb", "c"))
        self.assertTrue(final)

    def test_does_not_split_on_line_separator(self):
        parts, _ = textio.split_lines("a\u2028b\n")
        self.assertEqual(parts, ("a\u2028b",))

    def test_final_newline_flag(self):
        self.assertEqual(textio.split_lines("a\nb\n"), (("a", "b"), True))
        self.assertEqual(textio.split_lines("a\nb"), (("a", "b"), False))
        self.assertEqual(textio.split_lines(""), ((), False))


if __name__ == "__main__":
    unittest.main()

#@@ likegit-bundle @@ tests/test_winpath.py @@ 053a8e690eb66447f5278ddea4cc6b11142f41541e3aaf6fc86bfe2f9efcfe1b
"""Windows の 260 文字制限まわり。

深い階層を実際に作って確かめる。ここが壊れると、社内 PC の深い
プロジェクトで退避そのものができなくなる。
"""

from __future__ import annotations

import os
import shutil
import tempfile
import unittest
from pathlib import Path

from likegit import winpath

ON_WINDOWS = os.name == "nt"


class TestExtend(unittest.TestCase):
    @unittest.skipUnless(ON_WINDOWS, "Windows 専用")
    def test_adds_prefix(self):
        result = os.fspath(winpath.extend(Path(r"C:\work\src\a.py")))
        self.assertTrue(result.startswith("\\\\?\\"))
        self.assertTrue(result.endswith(r"C:\work\src\a.py"))

    @unittest.skipUnless(ON_WINDOWS, "Windows 専用")
    def test_pathlib_keeps_the_prefix(self):
        """pathlib が接頭辞を保つこと。ここが崩れると全部が静かに壊れる。"""
        extended = winpath.extend(Path(r"C:\work\a.py"))
        self.assertEqual(os.fspath(extended), r"\\?\C:\work\a.py")

    @unittest.skipUnless(ON_WINDOWS, "Windows 専用")
    def test_is_idempotent(self):
        once = winpath.extend(Path(r"C:\work\a.py"))
        self.assertEqual(winpath.extend(once), once)

    @unittest.skipUnless(ON_WINDOWS, "Windows 専用")
    def test_unc_path(self):
        result = os.fspath(winpath.extend(Path(r"\\server\share\a.py")))
        self.assertEqual(result, r"\\?\UNC\server\share\a.py")

    @unittest.skipUnless(ON_WINDOWS, "Windows 専用")
    def test_relative_is_made_absolute_and_normalized(self):
        """接頭辞付きは OS 側で正規化されないので、先に片付けておく必要がある。"""
        result = os.fspath(winpath.extend(Path("a/../b.py")))
        self.assertNotIn("..", result)
        self.assertNotIn("/", result)

    def test_non_windows_is_untouched(self):
        if ON_WINDOWS:
            self.skipTest("Windows では接頭辞が付くのが正しい")
        path = Path("/tmp/a.py")
        self.assertEqual(winpath.extend(path), path)


class TestLongPathIO(unittest.TestCase):
    """260 文字を超えるパスで、likegit が使う操作を一通り通す。"""

    def setUp(self):
        self.base = Path(tempfile.mkdtemp())
        self.addCleanup(shutil.rmtree, winpath.extend(self.base), True)

        deep = self.base
        while len(str(deep)) < 300:
            deep = deep / ("segment_" + "x" * 16)
        self.deep = deep
        self.assertGreater(len(str(self.deep)), winpath.MAX_PATH)

    def test_mkdir_write_read(self):
        winpath.extend(self.deep).mkdir(parents=True, exist_ok=True)
        self.assertTrue(winpath.extend(self.deep).is_dir())

        target = self.deep / "module.py"
        winpath.extend(target).write_bytes(b"x = 1\n")
        self.assertTrue(winpath.extend(target).is_file())
        self.assertEqual(winpath.extend(target).read_bytes(), b"x = 1\n")
        self.assertEqual(winpath.extend(target).stat().st_size, 6)

    def test_copy_at_depth(self):
        winpath.extend(self.deep).mkdir(parents=True, exist_ok=True)
        source = self.deep / "a.py"
        winpath.extend(source).write_bytes(b"original\n")
        target = self.deep / "b.py"
        shutil.copy2(winpath.extend(source), winpath.extend(target))
        self.assertEqual(winpath.extend(target).read_bytes(), b"original\n")

    def test_unlink_and_rmdir(self):
        winpath.extend(self.deep).mkdir(parents=True, exist_ok=True)
        target = self.deep / "a.py"
        winpath.extend(target).write_bytes(b"x\n")
        winpath.extend(target).unlink()
        self.assertFalse(winpath.extend(target).exists())
        winpath.extend(self.deep).rmdir()
        self.assertFalse(winpath.extend(self.deep).is_dir())

    def test_walk_finds_deep_files_and_strips_prefix(self):
        winpath.extend(self.deep).mkdir(parents=True, exist_ok=True)
        winpath.extend(self.deep / "a.py").write_bytes(b"x\n")

        found = []
        for dirpath, _dirnames, filenames in winpath.walk(self.base):
            self.assertFalse(str(dirpath).startswith("\\\\?\\"))
            found.extend(filenames)
        self.assertIn("a.py", found)

    @unittest.skipUnless(ON_WINDOWS, "Windows 専用")
    def test_plain_path_really_fails_here(self):
        """接頭辞なしでは本当に失敗すること。テストが空回りしていないことの確認。"""
        winpath.extend(self.deep).mkdir(parents=True, exist_ok=True)
        with self.assertRaises(OSError):
            (self.deep / "a.py").write_bytes(b"x\n")


class TestTooLong(unittest.TestCase):
    @unittest.skipUnless(ON_WINDOWS, "Windows 専用")
    def test_detects_long_paths(self):
        self.assertTrue(winpath.too_long(Path("C:/" + "x" * 300)))
        self.assertFalse(winpath.too_long(Path(r"C:\work\a.py")))


if __name__ == "__main__":
    unittest.main()

#@@ likegit-bundle @@ tools/audit.py @@ 7b37d9a9ac3ebbf709b48b71462999f438a73af2c753b12c9f2e63a2ed8ce252
"""likegit が本当に外へ出ていないことを、実行して確かめる。

    python tools/audit.py        終了コード 0 = 問題なし

「ソースを読めば通信していないのは分かる」で済ませず実測するのは、
このツールが業務コードを扱うため。持ち込みの可否を判断する人に
提出できる証跡を残す。

sys.addaudithook は CPython が内部で発火させる監査イベントを漏れなく拾う。
socket を直接使わず ctypes 経由で通信するような細工も、ここに現れる。

イベントは呼び出しスタックを辿って「likegit のコードに由来するか」で仕分ける。
Python の import 機構や標準ライブラリ内部 (@dataclass が __init__ をソースから
compile する等) の動作を、likegit の振る舞いと混同しないため。
"""

from __future__ import annotations  # 3.8 でも注釈を評価させない

import sys
import tempfile
from pathlib import Path

# リポジトリ直下から likegit を読めるようにする
sys.path.insert(0, str(Path(__file__).resolve().parent.parent))

NETWORK_EVENTS = (
    "socket.", "urllib.", "ftplib.", "smtplib.", "http.", "imaplib.",
    "poplib.", "nntplib.", "telnetlib.", "webbrowser.", "asyncio.",
)
PROCESS_EVENTS = (
    "subprocess.", "os.system", "os.exec", "os.spawn", "os.posix_spawn",
    "os.fork", "pty.spawn", "ctypes.", "winreg.", "os.putenv", "os.setuid",
)
DYNAMIC_EVENTS = ("exec", "eval", "compile", "pickle.loads", "marshal.loads")

LIKEGIT_DIR = ""   # likegit を import したあとに埋める
RECORDING = False  # likegit の実行区間か
_in_hook = False   # フック自身の再入を防ぐ

hits = {k: {"likegit": [], "other": []} for k in ("network", "process", "dynamic")}
files = {"write": {"likegit": [], "other": []}, "read": {"likegit": [], "other": []}}


def _from_likegit(immediate: bool = False) -> bool:
    """likegit のコードに由来するイベントか。

    immediate=False: スタックのどこかに likegit があるか。
        「likegit が (標準ライブラリ経由で) 起こした通信・書き込み」を捉える。
    immediate=True: 直接の呼び出し元が likegit か。
        「likegit 自身が exec/compile を呼んでいるか」はこちらで見る。
        @dataclass は dataclasses.py が __init__ をソースから compile し、
        import は importlib が .pyc を marshal.loads する。どちらも
        likegit のフレームがスタックに残るが、呼んでいるのは言語の側。
    """
    if not LIKEGIT_DIR:
        return False
    frame = sys._getframe(1)
    while frame is not None:
        name = frame.f_code.co_filename
        if name.startswith(LIKEGIT_DIR):
            return True
        if immediate and not name.startswith("<"):
            # 監査フック自身のフレーム以外で最初に見つかった実ファイル
            return False
        frame = frame.f_back
    return False


def _bucket(kind: str, event, args, immediate: bool = False) -> None:
    where = "likegit" if _from_likegit(immediate) else "other"
    hits[kind][where].append((event, repr(args)[:180]))


def hook(event, args):
    global _in_hook
    if _in_hook:
        return  # _getframe 自身が発火させる監査イベントを無視する
    _in_hook = True
    try:
        if event.startswith(NETWORK_EVENTS):
            _bucket("network", event, args)
        elif event.startswith(PROCESS_EVENTS):
            _bucket("process", event, args)
        elif event in DYNAMIC_EVENTS:
            # code object の exec は import 機構。文字列の exec だけが本物の動的実行。
            target = args[0] if args else None
            if event in ("exec", "eval") and not isinstance(target, (str, bytes)):
                return
            _bucket("dynamic", event, args, immediate=True)
        elif RECORDING and event == "open":
            path, mode = str(args[0]), str(args[1] or "")
            kind = "write" if any(c in mode for c in "wxa+") else "read"
            files[kind]["likegit" if _from_likegit() else "other"].append(path)
        elif RECORDING and event in (
            "os.remove", "os.rmdir", "os.rename", "os.mkdir", "shutil.copyfile"
        ):
            files["write"]["likegit" if _from_likegit() else "other"].append(str(args[0]))
    finally:
        _in_hook = False


sys.addaudithook(hook)

import likegit  # noqa: E402  (フック設置後に読み込む)
from likegit import cli, snapshot  # noqa: E402

LIKEGIT_DIR = str(Path(likegit.__file__).parent)


def run(*argv: str) -> int:
    global RECORDING
    RECORDING = True
    try:
        return cli.main(list(argv))
    finally:
        RECORDING = False


tmp = tempfile.TemporaryDirectory()
root = Path(tmp.name)
store = root / "store"
mine, theirs = root / "mine", root / "theirs"
mine.mkdir()
theirs.mkdir()

# --- 準備 (計測対象外) ---
(mine / "a.py").write_text("one\ntwo\nthree\n", encoding="utf-8")
(mine / "bin.dat").write_bytes(bytes([0, 1, 2]))

run("snapshot", str(mine), "-m", "監査用", "--store", str(store))
name = snapshot.listing(store)[0].name

(theirs / "a.py").write_text("one\ntwo\nTHEIRS\n", encoding="utf-8")
(theirs / "bin.dat").write_bytes(bytes([0, 9, 9]))
(theirs / "added.py").write_text("new\n", encoding="utf-8")
(mine / "a.py").write_text("ONE\ntwo\nthree\n", encoding="utf-8")

run("snapshots", "--store", str(store))
run("merge", "--base", name, "--mine", str(mine), "--theirs", str(theirs),
    "--out", str(root / "out"), "--store", str(store), "-v")
run("merge", "--base", name, "--mine", str(mine), "--theirs", str(theirs),
    "--in-place", "--store", str(store))

# --- 結果 ---
print("\n" + "=" * 74)
print("likegit 監査結果   (Python の監査フックで全イベントを捕捉)")
print("=" * 74)

for label, key in (
    ("通信          socket/urllib/http/smtp/asyncio ...", "network"),
    ("プロセス起動  subprocess/os.system/ctypes/winreg", "process"),
    ("動的コード実行 文字列の exec/eval, pickle.loads", "dynamic"),
):
    own = hits[key]["likegit"]
    other = hits[key]["other"]
    mark = "OK" if not own else "!! 要確認"
    print(f"  {label}")
    print(f"      likegit 由来: {len(own):>3} 件  [{mark}]      "
          f"(参考) 標準ライブラリ内部: {len(other)} 件")
    for event in own[:10]:
        print("        !!", event)

print("\n" + "-" * 74)


def plain(path: str) -> str:
    """`\\?\` 接頭辞を外す。

    likegit は 260 文字制限を避けるため I/O の直前で接頭辞を付ける
    (likegit/winpath.py)。監査イベントにはその形で現れるので、
    仕分けと表示の前に元の形へ戻す。
    """
    for prefix, replacement in (("\\\\?\\UNC\\", "\\\\"), ("\\\\?\\", "")):
        if path.startswith(prefix):
            return replacement + path[len(prefix):]
    return path


def split(paths: list[str]) -> tuple[list[str], list[str]]:
    cleaned = {plain(p) for p in paths}
    return (sorted(p for p in cleaned if str(root) in p),
            sorted(p for p in cleaned if str(root) not in p))


w_in, w_out = split(files["write"]["likegit"])
print(f"  likegit が書き込んだ先: 指定パス内 {len(w_in)} 件 / 指定パス外 {len(w_out)} 件"
      f"  [{'OK' if not w_out else '!! 要確認'}]")
for p in w_out:
    print("        !!", p)
for p in w_in:
    print("       ", Path(p).relative_to(root))

r_in, r_out = split(files["read"]["likegit"])
lib = [p for p in r_out if "Python3" in p or "site-packages" in p or "lib" in p.lower()]
stray = [p for p in r_out if p not in lib]
print(f"\n  likegit が読み込んだ先: 指定パス内 {len(r_in)} 件 / "
      f"指定パス外 {len(r_out)} 件 (Python 標準ライブラリ {len(lib)} 件)")
for p in stray:
    print("        ?", p)

ok = not (hits["network"]["likegit"] or hits["process"]["likegit"]
          or hits["dynamic"]["likegit"] or w_out or stray)
print("\n判定:", "完全ローカル。通信なし・指定パス外への書き込みなし。"
      if ok else "!! 要確認")
sys.exit(0 if ok else 1)

#@@ likegit-bundle @@ tools/check_compat.py @@ efc561bd8b95b0b9cf26593ab345aa50222632586ca864c9a42ee8f83df3af4b
"""持ち込み先の Python でも動くかを、ソースから静的に確かめる。

    python tools/check_compat.py         終了コード 0 = 問題なし

社内の Python のバージョンを選べないので、下限を宣言したら守り続ける必要がある。
新しい構文を 1 か所書いただけで持ち込み先で動かなくなり、しかも手元では
気づけない。CI が無い前提なので、機械で確認できる形にしておく。

見るのは 2 つ:
  1. 構文が下限バージョンで解釈できるか            (ast の feature_version)
  2. 実行時に評価される型が新しい書き方でないか    (list[str] や X | Y)

2 が要るのは、1 だけでは足りないため。`def f(x: list[str])` は 3.8 でも
構文としては通るが、注釈が評価される瞬間に TypeError になる。
`from __future__ import annotations` があれば注釈は文字列のままなので、
その有無も併せて見る。
"""

from __future__ import annotations

import ast
import sys
from pathlib import Path

MINIMUM = (3, 8)

#: 実行時に添字を付けると 3.9 以上が必要になる組み込み型
GENERICS = {"list", "dict", "tuple", "set", "frozenset", "type"}

ROOT = Path(__file__).resolve().parent.parent
TARGETS = ("likegit", "tests", "tools")


def sources() -> list[Path]:
    found: list[Path] = []
    for name in TARGETS:
        found.extend(sorted((ROOT / name).glob("*.py")))
    return found


def check_syntax(path: Path, source: str) -> list[str]:
    try:
        ast.parse(source, feature_version=MINIMUM)
    except SyntaxError as exc:
        return [f"{path.name}:{exc.lineno}: {MINIMUM[0]}.{MINIMUM[1]} で構文エラー: {exc.msg}"]
    return []


def _annotation_node_ids(tree: ast.AST) -> set[int]:
    """注釈の中にあるノードの id を集める。評価されない場所を除外するため。"""
    inside: set[int] = set()
    for node in ast.walk(tree):
        for field in ("annotation", "returns"):
            annotation = getattr(node, field, None)
            if annotation is not None:
                inside.update(id(sub) for sub in ast.walk(annotation))
    return inside


def check_runtime_types(path: Path, source: str, tree: ast.AST) -> list[str]:
    problems: list[str] = []
    inside = _annotation_node_ids(tree)

    has_annotations = any(
        getattr(node, "annotation", None) or getattr(node, "returns", None)
        for node in ast.walk(tree)
    )
    if has_annotations and "from __future__ import annotations" not in source:
        problems.append(
            f"{path.name}: 型注釈があるのに `from __future__ import annotations` が無い"
        )

    for node in ast.walk(tree):
        # 注釈の外で list[str] のように書くと 3.9 以上が必要になる
        if (
            isinstance(node, ast.Subscript)
            and isinstance(node.value, ast.Name)
            and node.value.id in GENERICS
            and id(node) not in inside
        ):
            problems.append(
                f"{path.name}:{node.lineno}: 実行時に評価される {ast.unparse(node)}"
                f" (typing.List 等か、注釈内へ)"
            )
        # 注釈の外の X | Y は 3.10 以上が必要 (diff3.Region はこれを避けている)
        if (
            isinstance(node, ast.BinOp)
            and isinstance(node.op, ast.BitOr)
            and id(node) not in inside
            and isinstance(node.left, ast.Name)
            and node.left.id[:1].isupper()
        ):
            problems.append(
                f"{path.name}:{node.lineno}: 実行時に評価される "
                f"{ast.unparse(node)} (typing.Union へ)"
            )
    return problems


def main() -> int:
    problems: list[str] = []
    files = sources()
    for path in files:
        source = path.read_text(encoding="utf-8")
        problems += check_syntax(path, source)
        try:
            tree = ast.parse(source)
        except SyntaxError:
            continue  # 構文エラーは上で報告済み
        problems += check_runtime_types(path, source, tree)

    label = f"Python {MINIMUM[0]}.{MINIMUM[1]} 互換チェック"
    print(f"{label}: {len(files)} ファイル")
    if problems:
        for problem in problems:
            print("  !!", problem)
        print(f"\n判定: {len(problems)} 件の問題。宣言した下限で動きません。")
        return 1
    print(f"\n判定: 問題なし。Python {MINIMUM[0]}.{MINIMUM[1]} 以上で動きます。")
    print(f"      (この環境は {sys.version.split()[0]})")
    return 0


if __name__ == "__main__":
    sys.exit(main())
'''


if __name__ == "__main__":
    sys.exit(main(sys.argv[1:]))
1
1
0

Register as a new user and use Qiita more conveniently

  1. You get articles that match your needs
  2. You can efficiently read back useful information
  3. You can use dark theme
What you can do with signing up
1
1

Delete article

Deleted articles cannot be recovered.

Draft of this article would be also deleted.

Are you sure you want to delete this article?