Fix ignoring module case insensitively

Don't lower whole contents, otherwise we break both the preprocessor,
as well as case in program names (which might be required for case of
actual executables)

Also only lower case module names, in order to preserve program name case

fortdepend/fort_depend.py

@@ -370,7 +370,7 @@ def remove_ignored_modules(self, ignore_modules=None):
         ignored_modules = ignore_modules + DEFAULT_IGNORED_MODULES
 
         # Remove from module dict
-        for ignore_mod in ignored_modules:
+        for ignore_mod in map(str.lower, ignored_modules):
             self.modules.pop(ignore_mod, None)
             # Remove from 'used' modules
             for module in self.modules.values():

fortdepend/units.py

@@ -47,7 +47,7 @@ def __init__(
 
         if readfile:
             with smart_open(self.filename, "r", encoding="utf-8") as f:
-                contents = f.read().lower()
+                contents = f.read()
 
             preprocessor = FortranPreprocessor()
 
@@ -114,13 +114,14 @@ def get_modules(self, contents, macros=None):
                 raise ValueError(error_string)
             for unit, start, end in zip(found_units, starts, ends):
                 name = unit.group("modname")
-                contains[name] = FortranModule(
+                mod = FortranModule(
                     unit_type=unit.group("unit_type"),
                     name=name,
                     source_file=self,
                     text=(contents, start, end),
                     macros=macros,
                 )
+                contains[mod.name] = mod
 
         # Remove duplicates before returning
         return contains
@@ -151,7 +152,7 @@ class FortranModule:
 
     def __init__(self, unit_type, name, source_file=None, text=None, macros=None):
         self.unit_type = unit_type.strip().lower()
-        self.name = name.strip().lower()
+        self.name = name.strip().lower() if self.unit_type == "module" else name.strip()
 
         if source_file is not None:
             self.source_file = source_file
@@ -184,7 +185,7 @@ def get_uses(self, contents, macros=None):
         for line in contents[self.defined_at : self.end]:
             found = re.match(USE_REGEX, line)
             if found:
-                uses.append(found.group("moduse").strip())
+                uses.append(found.group("moduse").strip().lower())
 
         # Remove duplicates
         uniq_mods = list(set(uses))

tests/test_fortranfile.py

@@ -33,7 +33,7 @@ def test_get_empty_uses(self):
 
     def test_get_single_module(self):
         contents = ["module modA", "end module modA"]
-        expected = {"modA": "FortranModule(module, 'moda', 'file.f90')"}
+        expected = {"moda": "FortranModule(module, 'moda', 'file.f90')"}
 
         assert self.testfile.modules is None
         module_list = self.testfile.get_modules(contents)
@@ -45,8 +45,8 @@ def test_get_single_module(self):
     def test_get_multiple_modules(self):
         contents = ["module modA", "end module modA", "module modB", "end module modB"]
         expected = {
-            "modA": "FortranModule(module, 'moda', 'file.f90')",
-            "modB": "FortranModule(module, 'modb', 'file.f90')",
+            "moda": "FortranModule(module, 'moda', 'file.f90')",
+            "modb": "FortranModule(module, 'modb', 'file.f90')",
         }
 
         assert self.testfile.modules is None
@@ -58,7 +58,7 @@ def test_get_multiple_modules(self):
 
     def test_module_with_module_procedure(self):
         contents = ["module modA", "module procedure foo", "end module modA"]
-        expected = {"modA": "FortranModule(module, 'moda', 'file.f90')"}
+        expected = {"moda": "FortranModule(module, 'moda', 'file.f90')"}
 
         assert self.testfile.modules is None
         module_list = self.testfile.get_modules(contents)
@@ -69,7 +69,7 @@ def test_module_with_module_procedure(self):
 
     def test_get_program(self):
         contents = ["program progA", "end program progA"]
-        expected = {"progA": "FortranModule(program, 'proga', 'file.f90')"}
+        expected = {"progA": "FortranModule(program, 'progA', 'file.f90')"}
 
         assert self.testfile.modules is None
         module_list = self.testfile.get_modules(contents)
@@ -88,9 +88,9 @@ def test_get_program_and_multiple_modules(self):
             "end module modB",
         ]
         expected = {
-            "modA": "FortranModule(module, 'moda', 'file.f90')",
-            "modB": "FortranModule(module, 'modb', 'file.f90')",
-            "progA": "FortranModule(program, 'proga', 'file.f90')",
+            "moda": "FortranModule(module, 'moda', 'file.f90')",
+            "modb": "FortranModule(module, 'modb', 'file.f90')",
+            "progA": "FortranModule(program, 'progA', 'file.f90')",
         }
 
         assert self.testfile.modules is None
@@ -119,7 +119,7 @@ def test_empty_uses(self):
 
     def test_get_single_module(self):
         testfile = FortranFile(filename="moduleA.f90", readfile=True)
-        expected = {"modA": "FortranModule(module, 'moda', 'moduleA.f90')"}
+        expected = {"moda": "FortranModule(module, 'moda', 'moduleA.f90')"}
 
         for key, value in expected.items():
             assert key in testfile.modules
@@ -128,11 +128,11 @@ def test_get_single_module(self):
     def test_get_program_and_multiple_modules(self):
         testfile = FortranFile(filename="multiple_modules.f90", readfile=True)
         expected = {
-            "modA": "FortranModule(module, 'moda', 'multiple_modules.f90')",
-            "modB": "FortranModule(module, 'modb', 'multiple_modules.f90')",
-            "modC": "FortranModule(module, 'modc', 'multiple_modules.f90')",
-            "modD": "FortranModule(module, 'modd', 'multiple_modules.f90')",
-            "progA": "FortranModule(program, 'proga', 'multiple_modules.f90')",
+            "moda": "FortranModule(module, 'moda', 'multiple_modules.f90')",
+            "modb": "FortranModule(module, 'modb', 'multiple_modules.f90')",
+            "modc": "FortranModule(module, 'modc', 'multiple_modules.f90')",
+            "modd": "FortranModule(module, 'modd', 'multiple_modules.f90')",
+            "progA": "FortranModule(program, 'progA', 'multiple_modules.f90')",
         }
 
         for key, value in expected.items():
@@ -141,16 +141,16 @@ def test_get_program_and_multiple_modules(self):
 
     def test_single_uses(self):
         testfile = FortranFile(filename="moduleB.f90", readfile=True)
-        assert testfile.uses == ["modA"]
+        assert testfile.uses == ["moda"]
 
     def test_multiple_uses(self):
         testfile = FortranFile(filename="moduleC.f90", readfile=True)
-        assert set(testfile.uses) == set(["modA", "modB"])
+        assert set(testfile.uses) == set(["moda", "modb"])
 
     def test_multiple_uses_in_multiple_units(self):
         testfile = FortranFile(filename="multiple_modules.f90", readfile=True)
         assert set(testfile.uses) == set(
-            ["modA", "modB", "modC", "modD", "iso_c_binding"]
+            ["moda", "modb", "modc", "modd", "iso_c_binding"]
         )
 
     def test_macro_replacement_dict(self):
@@ -159,21 +159,21 @@ def test_macro_replacement_dict(self):
             readfile=True,
             macros={"modA": "module_A", "modB": "module_B"},
         )
-        assert sorted(testfile.uses) == sorted(["module_A", "module_B"])
+        assert sorted(testfile.uses) == sorted(["module_a", "module_b"])
 
     def test_macro_replacement_list(self):
         testfile = FortranFile(
             filename="moduleC.f90",
             readfile=True,
             macros=["modA=module_A", "modB=module_B"],
         )
-        assert sorted(testfile.uses) == sorted(["module_A", "module_B"])
+        assert sorted(testfile.uses) == sorted(["module_a", "module_b"])
 
     def test_macro_replacement_single_value(self):
         testfile = FortranFile(
             filename="moduleC.f90", readfile=True, macros="modA=module_A"
         )
-        assert sorted(testfile.uses) == sorted(["module_A", "modB"])
+        assert sorted(testfile.uses) == sorted(["module_a", "modb"])
 
     def test_conditional_include(self):
         testfile = FortranFile(

tests/test_fortranproject.py

@@ -41,14 +41,14 @@ def test_get_all_files(self):
     def test_get_all_modules(self):
         testproject = FortranProject()
         expected_modules = [
-            "modA",
-            "modB",
-            "modC",
-            "modD",
-            "modE",
-            "modF",
-            "modG",
-            "modH",
+            "moda",
+            "modb",
+            "modc",
+            "modd",
+            "mode",
+            "modf",
+            "modg",
+            "modh",
             "progA",
             "test",
         ]
@@ -86,11 +86,11 @@ def test_exclude_files(self):
 
     def test_ignore_modules(self):
         testproject = FortranProject(
-            files="multiple_modules.f90", ignore_modules="modF"
+            files="multiple_modules.f90", ignore_modules=["modF", "modg"]
         )
-        assert sorted(["modG", "modH", "progA"]) == sorted(testproject.modules.keys())
-        assert [] == testproject.modules["modG"].uses
-        assert sorted(["modG", "modH"]) == sorted(
+        assert sorted(["modh", "progA"]) == sorted(testproject.modules.keys())
+        assert [] == testproject.modules["modh"].uses
+        assert sorted(["modh"]) == sorted(
             testproject.files["multiple_modules.f90"].uses
         )
 
@@ -334,8 +334,8 @@ def test_write_depends_skip_programs(self, datadir):
 
     def test_get_all_used_modules(self):
         expected_used = {
-            "progA": sorted(["modF", "modG", "modH"]),
-            "test": sorted(["modA", "modB", "modC", "modD"]),
+            "progA": sorted(["modf", "modg", "modh"]),
+            "test": sorted(["moda", "modb", "modc", "modd"]),
         }
 
         testproject = FortranProject()