search turkish by using english characters in emacs

search-turkish.el

(defvar turkish-char-map
  '(("ı" . "i") ("ğ" . "g") ("ü" . "u") ("ş" . "s") ("ö" . "o") ("ç" . "c")
    ("İ" . "I") ("Ğ" . "G") ("Ü" . "U") ("Ş" . "S") ("Ö" . "O") ("Ç" . "C"))
  "A mapping of Turkish characters to their English equivalents.")

(defun denormalize-turkish-text (text)
  "Generate alternative searches by replacing English characters with their Turkish equivalents."
  (let ((case-fold-search nil)
        (denormalized-queries (list text)))
    (dolist (pair turkish-char-map)
      (let ((eng-char (cdr pair))
            (tur-char (car pair)))
        (setq denormalized-queries
              (append denormalized-queries
                      (mapcar (lambda (query)
                                (replace-regexp-in-string eng-char tur-char query nil t))
                              denormalized-queries)))))
    (delete-dups denormalized-queries)))

(defun search-with-english-query (query)
  "Search within the current buffer using an English query and its Turkish equivalents."
  (interactive "sSearch (English query): ")
  (let ((queries (denormalize-turkish-text query)))
    (message "Generated search queries: %s" (string-join queries ", "))
    (occur (string-join queries "\\|"))))

(defun generate-denormalized-output (text)
  "Generate a string of alternative Turkish equivalents joined by | for the given text."
  (let ((alternatives (denormalize-turkish-text text)))
    (string-join alternatives "|")))

(defun test-denormalize-turkish-text ()
  "Test the denormalize-turkish-text function."
  (let ((all-passed t))
    (dolist (test test-cases-denormalize)
      (let ((input (car test))
            (expected (cdr test)))
        (let ((result (sort (denormalize-turkish-text input) 'string<)))
          (if (equal result (sort expected 'string<))
              (message "Passed: %s -> %s" input result)
            (progn
              (setq all-passed nil)
              (message "Failed: %s -> %s (expected %s)" input result expected))))))
    all-passed))

(defun test-generate-denormalized-output ()
  "Test the generate-denormalized-output function."
  (let ((all-passed t))
    (dolist (test test-cases-generate-denormalized-output)
      (let ((input (car test))
            (expected (cdr test)))
        (let ((output (generate-denormalized-output input)))
          (if (string= output expected)
              (message "Passed: %s -> %s" input output)
            (progn
              (setq all-passed nil)
              (message "Failed: %s -> %s (expected %s)" input output expected))))))
    all-passed))

(defvar test-cases-denormalize
  '(("kisi" . ("kisi" "kısı" "kişi" "kışı"))
    ("gorus" . ("gorus" "goruş" "gorüs" "gorüş" "görus" "göruş" "görüs" "görüş" "ğorus" "ğoruş" "ğorüs" "ğorüş" "ğörus" "ğöruş" "ğörüs" "ğörüş"))
    ("calisma" . ("calisma" "calişma" "calısma" "calışma" "çalisma" "çalişma" "çalısma" "çalışma"))
    ("isik" . ("isik" "işik" "ısık" "ışık"))
    ("pijamalı" . ("pijamalı" "pıjamalı"))
    ("hasta" . ("hasta" "haşta") )
    ("yağız" . ("yağız"))
    ("şoföre" . ("şoföre" "şöföre") )
    ("çabucak" . ("çabucak" "çabuçak" "çabücak" "çabüçak") )
    ("güvendi" .  ("güvendi" "güvendı" "ğüvendi" "ğüvendı") )))

(defvar test-cases-generate-denormalized-output
  '(("kisisel gelisim" . "kisisel gelisim|kısısel gelısım|kisisel ğelisim|kısısel ğelısım|kişişel gelişim|kışışel gelışım|kişişel ğelişim|kışışel ğelışım"))
  "Test cases for the function generate-denormalized-output.")

(defun run-all-tests ()
  "Run all test functions interactively and display the result."
  (interactive)
  (let ((all-tests-passed (and (test-denormalize-turkish-text)
                               (test-generate-denormalized-output))))
    (if all-tests-passed
        (message "All tests passed!")
      (message "Some tests failed."))))

(defvar tr-search-ignored-folders '(".git" "logseq/bak")
  "Folders to be ignored while searching in the roam directory.")

(defmacro define-search-function (name folder &optional ignored-folders)
  "Create an interactive search function with the given NAME to search in the specified FOLDER.
Allows optional IGNORED-FOLDERS to override default ignored directories."
  `(defun ,name (query &optional ignored-folders)
     ,(format "Search recursively in the %s directory for the given QUERY.
Allows optional IGNORED-FOLDERS as a parameter to override default ignored directories." folder)
     (interactive "sSearch (English query): ")
     (let* ((queries (denormalize-turkish-text query))
            (directory ,folder)
            (grep-find-ignored-directories (append grep-find-ignored-directories
                                                   (or ignored-folders tr-search-ignored-folders))))
       (rgrep (string-join queries "\\|") "*" directory))))

(define-search-function search-roam "/home/nwpwr/Dropbox/Notes/roam")