@k2works/claude-code-booster 2.7.1 → 3.1.0

package/lib/assets/docs/article/functional-desgin-ppp/clojure/11-command-pattern.md

@@ -0,0 +1,566 @@
+# 第11章: Command パターン
+
+## はじめに
+
+Command パターンは、リクエストをオブジェクトとしてカプセル化し、異なるリクエストでクライアントをパラメータ化したり、リクエストをキューに入れたり、操作の履歴を記録したりできるようにするパターンです。
+
+本章では、テキスト編集とキャンバス操作の例を通じて、コマンドのデータ化、Undo/Redo 機能、バッチ処理の実装を学びます。
+
+## 1. パターンの構造
+
+Command パターンは以下の要素で構成されます：
+
+- **Command**: コマンドのインターフェース（execute メソッド）
+- **ConcreteCommand**: 具体的なコマンドの実装
+- **Receiver**: コマンドを受け取り、実際の処理を行うオブジェクト
+- **Invoker**: コマンドを実行するオブジェクト
+
+```plantuml
+@startuml
+skinparam classAttributeIconSize 0
+
+interface "Command" as command {
+  +execute()
+  +undo()
+}
+
+class "ConcreteCommand" as concrete {
+  +receiver: Receiver
+  +state: any
+  +execute()
+  +undo()
+}
+
+class "Receiver" as receiver {
+  +action()
+}
+
+class "Invoker" as invoker {
+  +command: Command
+  +executeCommand()
+}
+
+class "Client" as client {
+  +createCommand()
+}
+
+concrete ..|> command
+invoker --> command : uses
+concrete --> receiver : calls
+client --> concrete : creates
+client --> receiver : creates
+
+note right of command
+  Commandはコマンドの
+  インターフェースを定義します。
+  executeとundoを持ちます。
+end note
+
+note right of invoker
+  Invokerはコマンドを保持し、
+  実行や履歴管理を行います。
+end note
+@enduml
+```
+
+## 2. Command インターフェース
+
+### マルチメソッドによる定義
+
+```clojure
+(ns command-pattern.command)
+
+(defmulti execute
+  "コマンドを実行する"
+  :type)
+
+(defmulti undo
+  "コマンドを取り消す"
+  :type)
+```
+
+## 3. テキスト操作コマンド
+
+### InsertCommand: テキスト挿入
+
+```clojure
+(ns command-pattern.text-commands
+  (:require [command-pattern.command :as cmd]))
+
+(defn make-insert-command
+  "挿入コマンドを作成"
+  [position text]
+  {:type :insert-command
+   :position position
+   :text text})
+
+(defmethod cmd/execute :insert-command [command]
+  (fn [document]
+    (let [pos (:position command)
+          text (:text command)
+          before (subs document 0 pos)
+          after (subs document pos)]
+      (str before text after))))
+
+(defmethod cmd/undo :insert-command [command]
+  (fn [document]
+    (let [pos (:position command)
+          len (count (:text command))
+          before (subs document 0 pos)
+          after (subs document (+ pos len))]
+      (str before after))))
+```
+
+### DeleteCommand: テキスト削除
+
+```clojure
+(defn make-delete-command
+  "削除コマンドを作成"
+  [start-position end-position deleted-text]
+  {:type :delete-command
+   :start-position start-position
+   :end-position end-position
+   :deleted-text deleted-text})
+
+(defmethod cmd/execute :delete-command [command]
+  (fn [document]
+    (let [start (:start-position command)
+          end (:end-position command)
+          before (subs document 0 start)
+          after (subs document end)]
+      (str before after))))
+
+(defmethod cmd/undo :delete-command [command]
+  (fn [document]
+    (let [start (:start-position command)
+          text (:deleted-text command)
+          before (subs document 0 start)
+          after (subs document start)]
+      (str before text after))))
+```
+
+### ReplaceCommand: テキスト置換
+
+```clojure
+(defn make-replace-command
+  "置換コマンドを作成"
+  [start-position old-text new-text]
+  {:type :replace-command
+   :start-position start-position
+   :old-text old-text
+   :new-text new-text})
+
+(defmethod cmd/execute :replace-command [command]
+  (fn [document]
+    (let [start (:start-position command)
+          old-len (count (:old-text command))
+          new-text (:new-text command)
+          before (subs document 0 start)
+          after (subs document (+ start old-len))]
+      (str before new-text after))))
+
+(defmethod cmd/undo :replace-command [command]
+  (fn [document]
+    (let [start (:start-position command)
+          new-len (count (:new-text command))
+          old-text (:old-text command)
+          before (subs document 0 start)
+          after (subs document (+ start new-len))]
+      (str before old-text after))))
+```
+
+### クラス図
+
+```plantuml
+@startuml
+skinparam classAttributeIconSize 0
+
+interface "TextCommand" as textCmd {
+  +execute(command): fn
+  +undo(command): fn
+}
+
+class "InsertCommand" as insert {
+  +type: :insert-command
+  +position: number
+  +text: string
+  +execute(command)
+  +undo(command)
+}
+
+class "DeleteCommand" as delete {
+  +type: :delete-command
+  +start-position: number
+  +end-position: number
+  +deleted-text: string
+  +execute(command)
+  +undo(command)
+}
+
+class "ReplaceCommand" as replace {
+  +type: :replace-command
+  +start-position: number
+  +old-text: string
+  +new-text: string
+  +execute(command)
+  +undo(command)
+}
+
+insert ..|> textCmd
+delete ..|> textCmd
+replace ..|> textCmd
+
+note right of textCmd
+  コマンドは状態変更関数を返します。
+  execute: document → new-document
+  undo: document → previous-document
+end note
+@enduml
+```
+
+### 使用例
+
+```clojure
+(require '[command-pattern.command :as cmd])
+(require '[command-pattern.text-commands :as tc])
+
+;; 挿入コマンド
+(def insert-cmd (tc/make-insert-command 5 " World"))
+(def execute-fn (cmd/execute insert-cmd))
+(execute-fn "Hello")
+;; => "Hello World"
+
+;; Undo
+(def undo-fn (cmd/undo insert-cmd))
+(undo-fn "Hello World")
+;; => "Hello"
+```
+
+## 4. キャンバス操作コマンド
+
+### AddShapeCommand: 図形追加
+
+```clojure
+(ns command-pattern.canvas-commands
+  (:require [command-pattern.command :as cmd]))
+
+(defn make-add-shape-command
+  "図形追加コマンドを作成"
+  [shape]
+  {:type :add-shape-command
+   :shape shape})
+
+(defmethod cmd/execute :add-shape-command [command]
+  (fn [canvas]
+    (update canvas :shapes conj (:shape command))))
+
+(defmethod cmd/undo :add-shape-command [command]
+  (fn [canvas]
+    (update canvas :shapes
+            (fn [shapes]
+              (filterv #(not= (:id %) (get-in command [:shape :id])) shapes)))))
+```
+
+### MoveShapeCommand: 図形移動
+
+```clojure
+(defn make-move-shape-command
+  "図形移動コマンドを作成"
+  [shape-id dx dy]
+  {:type :move-shape-command
+   :shape-id shape-id
+   :dx dx
+   :dy dy})
+
+(defmethod cmd/execute :move-shape-command [command]
+  (fn [canvas]
+    (update canvas :shapes
+            (fn [shapes]
+              (mapv (fn [shape]
+                      (if (= (:id shape) (:shape-id command))
+                        (-> shape
+                            (update :x + (:dx command))
+                            (update :y + (:dy command)))
+                        shape))
+                    shapes)))))
+
+(defmethod cmd/undo :move-shape-command [command]
+  (fn [canvas]
+    (update canvas :shapes
+            (fn [shapes]
+              (mapv (fn [shape]
+                      (if (= (:id shape) (:shape-id command))
+                        (-> shape
+                            (update :x - (:dx command))
+                            (update :y - (:dy command)))
+                        shape))
+                    shapes)))))
+```
+
+## 5. コマンド実行器
+
+### CommandExecutor の実装
+
+```clojure
+(ns command-pattern.command-executor
+  (:require [command-pattern.command :as cmd]))
+
+(defn make-executor
+  "コマンド実行器を作成"
+  [initial-state]
+  {:state initial-state
+   :undo-stack []
+   :redo-stack []})
+
+(defn execute-command
+  "コマンドを実行し、履歴に追加"
+  [executor command]
+  (let [state (:state executor)
+        execute-fn (cmd/execute command)
+        new-state (execute-fn state)]
+    (-> executor
+        (assoc :state new-state)
+        (update :undo-stack conj command)
+        (assoc :redo-stack []))))
+
+(defn undo-command
+  "最後のコマンドを取り消す"
+  [executor]
+  (if (seq (:undo-stack executor))
+    (let [command (peek (:undo-stack executor))
+          state (:state executor)
+          undo-fn (cmd/undo command)
+          new-state (undo-fn state)]
+      (-> executor
+          (assoc :state new-state)
+          (update :undo-stack pop)
+          (update :redo-stack conj command)))
+    executor))
+
+(defn redo-command
+  "最後に取り消したコマンドを再実行"
+  [executor]
+  (if (seq (:redo-stack executor))
+    (let [command (peek (:redo-stack executor))
+          state (:state executor)
+          execute-fn (cmd/execute command)
+          new-state (execute-fn state)]
+      (-> executor
+          (assoc :state new-state)
+          (update :redo-stack pop)
+          (update :undo-stack conj command)))
+    executor))
+```
+
+### シーケンス図
+
+```plantuml
+@startuml
+actor User
+participant "Invoker\n(CommandExecutor)" as invoker
+participant "Command" as command
+participant "State\n(Document/Canvas)" as state
+
+== Execute ==
+User -> invoker : execute-command(command)
+activate invoker
+invoker -> command : execute(command)
+activate command
+command --> invoker : execute-fn
+deactivate command
+invoker -> state : execute-fn(state)
+activate state
+state --> invoker : new-state
+deactivate state
+invoker -> invoker : push to undo-stack
+invoker --> User : updated executor
+deactivate invoker
+
+== Undo ==
+User -> invoker : undo-command()
+activate invoker
+invoker -> invoker : pop from undo-stack
+invoker -> command : undo(command)
+activate command
+command --> invoker : undo-fn
+deactivate command
+invoker -> state : undo-fn(state)
+activate state
+state --> invoker : previous-state
+deactivate state
+invoker -> invoker : push to redo-stack
+invoker --> User : updated executor
+deactivate invoker
+
+note right
+  Executorはコマンドの履歴を管理し、
+  Undo/Redo機能を提供します
+end note
+@enduml
+```
+
+### 使用例
+
+```clojure
+(require '[command-pattern.command-executor :as exec])
+(require '[command-pattern.text-commands :as tc])
+
+;; 実行器を作成
+(def executor (exec/make-executor "Hello"))
+
+;; コマンドを実行
+(def executor (exec/execute-command executor (tc/make-insert-command 5 " World")))
+(exec/get-state executor)
+;; => "Hello World"
+
+;; Undo
+(def executor (exec/undo-command executor))
+(exec/get-state executor)
+;; => "Hello"
+
+;; Redo
+(def executor (exec/redo-command executor))
+(exec/get-state executor)
+;; => "Hello World"
+```
+
+## 6. バッチ処理とマクロコマンド
+
+### バッチ処理
+
+```clojure
+(defn execute-batch
+  "複数のコマンドをまとめて実行"
+  [executor commands]
+  (reduce execute-command executor commands))
+
+(defn undo-all
+  "すべてのコマンドを取り消す"
+  [executor]
+  (if (can-undo? executor)
+    (recur (undo-command executor))
+    executor))
+```
+
+### MacroCommand
+
+```clojure
+(defn make-macro-command
+  "複合コマンドを作成"
+  [commands]
+  {:type :macro-command
+   :commands commands})
+
+(defmethod cmd/execute :macro-command [macro]
+  (fn [state]
+    (reduce (fn [s command]
+              ((cmd/execute command) s))
+            state
+            (:commands macro))))
+
+(defmethod cmd/undo :macro-command [macro]
+  (fn [state]
+    (reduce (fn [s command]
+              ((cmd/undo command) s))
+            state
+            (reverse (:commands macro)))))
+```
+
+### MacroCommand の図
+
+```plantuml
+@startuml
+skinparam classAttributeIconSize 0
+
+class "MacroCommand" as macro {
+  +type: :macro-command
+  +commands: vector
+  +execute(): fn
+  +undo(): fn
+}
+
+class "Command1" as cmd1 {
+  +execute()
+  +undo()
+}
+
+class "Command2" as cmd2 {
+  +execute()
+  +undo()
+}
+
+class "Command3" as cmd3 {
+  +execute()
+  +undo()
+}
+
+macro --> cmd1
+macro --> cmd2
+macro --> cmd3
+
+note right of macro
+  MacroCommandは複数のコマンドを
+  一つのコマンドとして扱います。
+
+  execute: 順番に実行
+  undo: 逆順に取り消し
+end note
+@enduml
+```
+
+### 使用例
+
+```clojure
+;; MacroCommand を使った複合操作
+(def commands [(tc/make-insert-command 5 " World")
+               (tc/make-insert-command 11 "!")])
+(def macro (exec/make-macro-command commands))
+
+(def executor (exec/execute-command (exec/make-executor "Hello") macro))
+(exec/get-state executor)
+;; => "Hello World!"
+
+;; 一度のUndoで全体を取り消す
+(def executor (exec/undo-command executor))
+(exec/get-state executor)
+;; => "Hello"
+```
+
+## 7. パターンの利点
+
+1. **操作のオブジェクト化**: 操作をデータとして表現できる
+2. **Undo/Redo**: 操作履歴の管理が容易
+3. **バッチ処理**: 複数の操作をまとめて処理
+4. **遅延実行**: コマンドをキューに入れて後で実行
+5. **ログ記録**: 操作の履歴をログとして保存
+
+## 8. 関数型プログラミングでの特徴
+
+Clojure での Command パターンの実装には以下の特徴があります：
+
+1. **コマンドはデータ**: コマンドは単なるマップとして表現
+2. **純粋関数**: execute/undo は状態変更関数を返す純粋関数
+3. **イミュータブル**: 状態は変更されず、新しい状態が返される
+4. **マルチメソッド**: 型に基づいたディスパッチで多態性を実現
+
+## まとめ
+
+本章では、Command パターンについて学びました：
+
+1. **コマンドのデータ化**: 操作をマップとして表現
+2. **Undo/Redo**: コマンド履歴による取り消しと再実行
+3. **バッチ処理**: 複数コマンドの一括実行
+4. **MacroCommand**: 複合コマンドの実装
+
+Command パターンは、操作の履歴管理や取り消し機能が必要な場面で非常に有効です。
+
+## 参考コード
+
+本章のコード例は以下のファイルで確認できます：
+
+- ソースコード: `apps/clojure/part4/src/command_pattern/`
+- テストコード: `apps/clojure/part4/spec/command_pattern/`
+
+## 次章予告
+
+次章では、**Visitor パターン**について学びます。データ構造と操作を分離し、新しい操作を追加しやすくする方法を探ります。