Remove unused functions from form_edit/core

Removed 9 functions that were only referenced in tests:
- find-docstring, edit-docstring
- is-comment-form?, is-line-comment?
- find-comment-block, edit-comment-block
- get-form-summary, valid-form-to-include?, extract-form-name

These functions are superseded by implementations in pattern_core.clj

Author: Bruce Hauman

src/clojure_mcp/tools/form_edit/core.clj

@@ -272,329 +272,6 @@
   (mapv (fn [[row col]] (row-col->offset source-str row col))
         positions))
 
-;; Functions for working with docstrings
-
-(defn find-docstring
-  "Finds the docstring node of a top-level form.
-   
-   Arguments:
-   - zloc: The zipper location to start searching from
-   - tag: The form type (e.g., 'defn, 'def)
-   - name: The name of the form
-   
-   Returns a map with:
-   - :zloc - the zipper positioned at the docstring node (or nil if not found)
-   - :similar-matches - a vector of potential namespace-qualified matches from find-top-level-form"
-  [zloc tag name]
-  (let [find-result (find-top-level-form zloc tag name)
-        form-zloc (:zloc find-result)]
-    (if-not form-zloc
-      find-result ;; Return the result with nil :zloc and any similar-matches
-      (let [tag-zloc (z/down form-zloc) ;; Move to the tag (defn, def, etc.)
-            name-zloc (z/right tag-zloc) ;; Move to the name
-            docstring-candidate (z/right name-zloc) ;; Move to potential docstring
-            docstring-zloc (when (and docstring-candidate
-                                   ;; Check for both :token (single-line) and :multi-line (multi-line) tags
-                                      (contains? #{:token :multi-line} (z/tag docstring-candidate))
-                                      (string? (z/sexpr docstring-candidate)))
-                             docstring-candidate)]
-        {:zloc docstring-zloc
-         :similar-matches (:similar-matches find-result)}))))
-
-(defn edit-docstring
-  "Edit a docstring in a top-level form.
-   
-   Arguments:
-   - zloc: The zipper location to start searching from
-   - tag: The form type (e.g., 'defn, 'def)
-   - name: The name of the form
-   - new-docstring: The new docstring content
-   
-   Returns a map with:
-   - :zloc - the updated zipper (or nil if form/docstring not found)
-   - :similar-matches - a vector of potential namespace-qualified matches"
-  [zloc tag name new-docstring]
-  (let [docstring-result (find-docstring zloc tag name)
-        docstring-zloc (:zloc docstring-result)]
-    (if docstring-zloc
-      ;; Found the docstring, update it
-      {:zloc (z/replace docstring-zloc (n/string-node new-docstring))
-       :similar-matches (:similar-matches docstring-result)}
-      ;; Couldn't find docstring
-      docstring-result)))
-
-;; Functions for working with comments
-
-(defn is-comment-form?
-  "Check if a zloc is a (comment ...) form.
-   
-   Arguments:
-   - zloc: The zipper location to check
-   
-   Returns true if the form is a comment form."
-  [zloc]
-  (try
-    (and (z/seq? zloc)
-         (let [first-child (z/down zloc)]
-           (and first-child
-                (= (z/sexpr first-child) 'comment))))
-    (catch Exception _ false)))
-
-(defn is-line-comment?
-  "Check if a zloc is a line comment.
-   
-   Arguments:
-   - zloc: The zipper location to check
-   
-   Returns true if the node is a line comment."
-  [zloc]
-  (try
-    (= (-> zloc z/node n/tag) :comment)
-    (catch Exception _ false)))
-
-(defn find-comment-block
-  "Find a comment block (either a 'comment' form or consecutive comment lines)
-   that contains a specific substring.
-   
-   This version properly handles comment blocks at the end of the file.
-   
-   Arguments:
-   - source: The source string to search in
-   - comment-substring: The substring to look for
-   
-   Returns a map with :type, :start, :end, and :content keys,
-   or nil if no matching comment block is found."
-  [source comment-substring]
-  (let [zloc (z/of-string source {:track-position? true})
-        lines (str/split-lines source)]
-
-    ;; First, try to find a comment form
-    (loop [loc zloc]
-      (cond
-        ;; No more forms
-        (nil? loc)
-        (let [;; Process line by line to find comment blocks
-              result (reduce
-                      (fn [[blocks current-block] [idx line]]
-                        (cond
-                         ;; If we're already tracking a block and the line is a comment
-                          (and current-block
-                               (str/starts-with? (str/trim line) ";;"))
-                          [blocks (update current-block :lines conj line)]
-
-                         ;; If we're tracking a block and hit a non-comment line
-                          current-block
-                          [(conj blocks (assoc current-block :end (dec idx))) nil]
-
-                         ;; If this is a new comment line
-                          (str/starts-with? (str/trim line) ";;")
-                          [blocks {:start idx
-                                   :lines [line]}]
-
-                         ;; Otherwise, continue
-                          :else
-                          [blocks nil]))
-                      [[] nil]
-                      (map-indexed vector lines))
-
-              ;; Extract the blocks and potential unfinished block
-              [blocks current-block] result
-
-              ;; Finalize blocks, including any unfinished block at EOF
-              final-blocks (if current-block
-                             (conj blocks (assoc current-block
-                                                 :end (+ (:start current-block)
-                                                         (dec (count (:lines current-block))))))
-                             blocks)
-
-              ;; Find the first consecutive comment block containing the substring
-              matching-block (first (filter #(some (fn [line]
-                                                     (str/includes? line comment-substring))
-                                                   (:lines %))
-                                            final-blocks))]
-
-          (when matching-block
-            {:type :line-comments
-             :start (:start matching-block)
-             :end (:end matching-block)
-             :content (str/join "\n" (:lines matching-block))}))
-
-        ;; Check if current form is a comment form
-        (is-comment-form? loc)
-        (let [comment-str (z/string loc)]
-          (if (str/includes? comment-str comment-substring)
-            (let [pos (z/position-span loc)]
-              {:type :comment-form
-               :start (first pos) ;; [row col]
-               :end (second pos) ;; [row col]
-               :content comment-str
-               :zloc loc})
-            (recur (z/right loc))))
-
-        ;; Move to the next form
-        :else (recur (z/right loc))))))
-
-(defn edit-comment-block
-  "Edit a comment block in the source code.
-   
-   Arguments:
-   - source: The source string
-   - comment-substring: Substring to identify the comment block
-   - new-content: New content to replace the comment block with
-   
-   Returns the updated source code string, or the original if no matching block was found."
-  [source comment-substring new-content]
-  (let [block (find-comment-block source comment-substring)]
-    (if (nil? block)
-      source ;; No matching block found
-      (let [lines (str/split-lines source)]
-        (case (:type block)
-          ;; For comment forms, use zloc to replace
-          :comment-form
-          (-> (:zloc block)
-              (z/replace (p/parse-string new-content))
-              z/root-string)
-
-          ;; For line comments, replace the relevant lines
-          :line-comments
-          (let [start (:start block)
-                end (:end block)
-                new-lines (str/split-lines new-content)
-                result (concat
-                        (take start lines)
-                        new-lines
-                        (drop (inc end) lines))]
-            (str/join "\n" result)))))))
-
-;; Form summary and visualization functions
-
-;; Forward declaration for extract-form-name to enable better organization
-(declare extract-form-name)
-
-(defn get-form-summary
-  "Get a summarized representation of a Clojure form showing only up to the argument list.
-   
-   Arguments:
-   - zloc: The zipper location of the form
-   
-   Returns a string representation of the form summary, or nil if not a valid form."
-  [zloc]
-  (try
-    (let [sexpr (z/sexpr zloc)]
-      (when (and (seq? sexpr) (symbol? (first sexpr)))
-        (let [form-sym (first sexpr)
-              form-type (name form-sym)
-              base-type (if (str/ends-with? form-type "-")
-                          (subs form-type 0 (dec (count form-type)))
-                          form-type)
-              form-name (extract-form-name sexpr)]
-
-          (case base-type
-            "defn" (let [zloc-down (z/down zloc) ; Move to the symbol (defn/defn-)
-                         name-loc (and zloc-down (z/right zloc-down)) ; Move to name
-                         maybe-docstring (and name-loc (z/right name-loc)) ; Next node after name
-                         args-loc (if (and maybe-docstring
-                                           (contains? #{:token :multi-line} (z/tag maybe-docstring))
-                                           (string? (z/sexpr maybe-docstring)))
-                                    (z/right maybe-docstring) ; Skip docstring to find args
-                                    maybe-docstring)] ; No docstring, args right after name
-                     (if (and args-loc (= (z/tag args-loc) :vector))
-                       (str "(" form-type " " form-name " " (z/string args-loc) " ...)")
-                       (str "(" form-type " " form-name " [...] ...)")))
-
-            "defmacro" (let [zloc-down (z/down zloc) ; Move to the symbol (defmacro/defmacro-)
-                             name-loc (and zloc-down (z/right zloc-down)) ; Move to name
-                             maybe-docstring (and name-loc (z/right name-loc)) ; Next node after name
-                             args-loc (if (and maybe-docstring
-                                               (contains? #{:token :multi-line} (z/tag maybe-docstring))
-                                               (string? (z/sexpr maybe-docstring)))
-                                        (z/right maybe-docstring) ; Skip docstring to find args
-                                        maybe-docstring)] ; No docstring, args right after name
-                         (if (and args-loc (= (z/tag args-loc) :vector))
-                           (str "(" form-type " " form-name " " (z/string args-loc) " ...)")
-                           (str "(" form-type " " form-name " [...] ...)")))
-
-            "defmethod" (let [zloc-down (z/down zloc) ; Move to the symbol "defmethod"
-                              method-loc (and zloc-down (z/right zloc-down)) ; Move to method name
-                              method-sym (and method-loc (z/sexpr method-loc))
-                              method-name (if (symbol? method-sym)
-                                            (if (namespace method-sym)
-                                              (str (namespace method-sym) "/" (name method-sym))
-                                              (name method-sym))
-                                            "unknown")
-                              dispatch-loc (and method-loc (z/right method-loc)) ; Move to dispatch value
-                              dispatch-val (and dispatch-loc (z/sexpr dispatch-loc))
-                              dispatch-str (and dispatch-val (pr-str dispatch-val))
-                              ;; Find the argument vector after the dispatch value
-                              args-loc (loop [loc (and dispatch-loc (z/right dispatch-loc))]
-                                         (cond
-                                           (nil? loc) nil
-                                           (= (z/tag loc) :vector) loc
-                                           :else (recur (z/right loc))))]
-                          (if (and args-loc (= (z/tag args-loc) :vector))
-                            (str "(" form-type " " method-name " " dispatch-str " " (z/string args-loc) " ...)")
-                            (str "(" form-type " " method-name " " dispatch-str " [...] ...)")))
-
-            "def" (str "(" form-type " " form-name " ...)")
-            "deftest" (str "(" form-type " " form-name " ...)")
-            "ns" (z/string zloc) ; Always show the full namespace
-            (str "(" form-type " " (or form-name "") " ...)")))))
-    (catch Exception e
-      ;; Provide a fallback in case of errors
-      (try
-        (let [raw-str (z/string zloc)]
-          (if (< (count raw-str) 60)
-            raw-str
-            (str (subs raw-str 0 57) "...")))
-        (catch Exception _
-          nil)))))
-
-(defn valid-form-to-include?
-  "Check if a form should be included in the collapsed view.
-   Excludes forms like comments, unevals, whitespace, etc.
-   
-   Arguments:
-   - zloc: The zipper location to check
-   
-   Returns:
-   - true if the form should be included, false otherwise"
-  [zloc]
-  (try
-    (when zloc
-      (let [tag (z/tag zloc)]
-        ;; Exclude specific node types we don't want to process
-        (not (or
-              ;; Skip uneval forms (#_)
-              (= tag :uneval)
-              ;; Skip whitespace
-              (= tag :whitespace)
-              ;; Skip newlines
-              (= tag :newline)
-              ;; Skip comments
-              (= tag :comment)))))
-    (catch Exception _
-      ;; If we can't determine the type, skip it to be safe
-      false)))
-
-;; TODO form name can be a keyword if its a spec 
-(defn extract-form-name
-  "Extract the name of a form from its sexpr representation.
-   For example, from (defn foo [x] ...) it extracts 'foo'.
-   
-   Arguments:
-   - sexpr: The S-expression to extract the name from
-   
-   Returns:
-   - The name as a string, or nil if no name could be extracted"
-  [sexpr]
-  (try
-    (when (and (seq? sexpr)
-               (> (count sexpr) 1)
-               (symbol? (second sexpr)))
-      (name (second sexpr)))
-    (catch Exception _
-      nil)))
-
 ;; Source code formatting
 
 (def default-formatting-options