Rewrite in class, cleaner

link_fixer.py

@@ -1,47 +1,87 @@
 import argparse
 import os
+from os.path import relpath
 from pathlib import Path
 import sys
 
+from file_type import FileType
 from search_file import search_file
-from swap_link import swap_link
 
-def link_fixer(ln_path, tgt_dir_path):
-    ln_is_dir = False
+class Link(FileType):
 
-    link = Path(ln_path)
-    tgt_dir = Path(tgt_dir_path)
+    @classmethod
+    def fix(cls, ln_str, tgt_dir_str):
 
-    if link.is_dir():
-        ln_is_dir = True
-    elif not link.is_symlink():
-        if not link.exists():
-            sys.exit("Link argument matches no file or directory")
-        else:
-            sys.exit("Link argument is not a symbolic link")
-    elif link.exists():
-        sys.exit("Link is not broken!")
+        link = Path(ln_str)
+        tgt_dir = Path(tgt_dir_str)
 
-    if not tgt_dir.exists():
-        sys.exit("Target directory not found.")
-    if not tgt_dir.is_dir():
-        sys.exit("Pointed target is not a directory")
+        try:
+            to_be_fixed = cls.get_file_type(link)
+        except Exception as e:
+            #print(f"Error: could not access link {ln_str}.")
+            sys.exit(f"Error: could not access link {ln_str}.")
 
-    print("Starting link fixer")
-    if ln_is_dir:
-        print("Links dir: \t", link)
-    else:
-        print("Link: \t\t", link)
-    print("Targets dir: \t", tgt_dir)
-    if ln_is_dir:
-        sys.exit("But ln dir version not yet implemented. Sorry!")
+        if not tgt_dir.is_dir():
+            sys.exit(f"Error: target dir {tgt_dir} does not seem to exist or be a directory. Abort.")
 
-    tgt = search_file(link.resolve().name, tgt_dir_path)
-    swap_link(ln_path, tgt)
+        match to_be_fixed:
+            case "file":
+                sys.exit(f"Error: link {ln_str} is not a link at all. Abort.")
+            case "symlink":
+                #print(f"Error: link {ln_str} is not broken. Abort.")
+                sys.exit(f"Error: link {ln_str} is not broken. Abort.")
+            case "broken-link":
+                try:
+                    tgt = search_file(link.resolve().name, tgt_dir)
+                except Exception as e:
+                    #print("No match for link reference filename in target directory.")
+                    sys.exit("Error: no match for link target in {tgt_dir_str}")
+                cls._swap_link(link, tgt)
+            case "directory":
+                for root, dirs, files in os.walk(to_be_fixed):
+                    for name in files:
+                        if get_file_type(name) == "broken-link":
+                            cls.link_fixer(name, tgt_dir_path)
+
+    @classmethod
+    def _swap_link(cls, lnk, tgt):
+        # relnk lnk to tgt as symlink, relative path
+        # assumes type verifications already made!
+        #lnk: symbolic link to swap, Path
+        #tgt: target for new link, Path
+        
+        tpath = Path(tgt)
+        if tpath.is_symlink():
+            if not tpath.exists():
+                raise Exception("Target is also a broken link!")
+            elif tpath.readlink().resolve() == lnpath.resolve() :
+                raise Exception("Target is a link to link to be fixed...")
+        
+        tmp_suffix = 0
+        tmp_prefix = 'temp'
+        tmp_name = tmp_prefix + str(tmp_suffix)
+        tmp_path = Path(lnk.parent / tmp_name)
+        while tmp_path.exists() or tmp_path.is_symlink():
+            tmp_suffix += 1
+            tmp_name = tmp_prefix + str(tmp_suffix)
+            tmp_path = Path(lnk.parent / tmp_name)
+
+        sym_path = relpath(tgt, lnk.resolve())[3:]
+
+        try:
+            tmp_path.symlink_to(sym_path)
+        except Exception as e:
+            print(f"Attempted to create tmp link: {tmp_name}")
+            #raise Exception("Failed to create new symlink. Check permissions!")
+
+        try:
+            lnk.unlink()
+        except Exception:
+            tmp_path.unlink()
+            #raise Exception("Failed to remove broken link. Check permissions!")
+        
+        tmp_path.rename(lnk)
     
-def fix_link(lnk, tgt_dir_path):
-    return True
-
 
 if __name__ == "__main__":
 
@@ -50,13 +90,13 @@ if __name__ == "__main__":
         Search for file with same name as link in target dir.
         Replace link to point to found file if any.
         '''
-
     )
     parser.add_argument("link", type=str, help="Broken link, or directory with broken links")
     parser.add_argument("tgt_path", type=str, help="Directory in which to find target(s)")
     args = parser.parse_args()
 
-    link = Path(args.link)
-    tgt_dir = Path(args.tgt_path)
+    link = args.link
+    tgt_dir = args.tgt_path
+
+    Link.fix(link, tgt_dir)
 
-    link_fixer(link, tgt_dir)