Case-insensitive ZIP loading

Author: NotHyper-474

polymod/fs/SysZipFileSystem.hx

@@ -1,5 +1,6 @@
 package polymod.fs;
 
+import polymod.util.insensitive.*;
 import polymod.fs.ZipFileSystem.ZipFileSystemParams;
 #if !sys
 class SysZipFileSystem extends polymod.fs.StubFileSystem
@@ -33,7 +34,7 @@ class SysZipFileSystem extends SysFileSystem
 	/**
 	 * Specifies the name of the ZIP that contains each file.
 	 */
-	var filesLocations:Map<String, String>;
+	var filesLocations:InsensitiveMap<String>;
 
 	/**
 	 * Specifies the names of available directories within the ZIP files.
@@ -48,7 +49,7 @@ class SysZipFileSystem extends SysFileSystem
 	public function new(params:ZipFileSystemParams)
 	{
 		super(params);
-		filesLocations = new Map<String, String>();
+		filesLocations = new InsensitiveMap();
 		zipParsers = new Map<String, ZipParser>();
 		fileDirectories = [];
 
@@ -125,8 +126,9 @@ class SysZipFileSystem extends SysFileSystem
 		return super.isDirectory(path);
 	}
 
-	public override function readDirectory(path:String)
+	public override function readDirectory(path:String):Array<String>
 	{
+		var path:InsensitiveString = path;
 		// Remove trailing slash
 		if (path.endsWith("/"))
 			path = path.substring(0, path.length - 1);

polymod/util/insensitive/InsensitiveMap.hx

@@ -0,0 +1,81 @@
+package polymod.util.insensitive;
+
+import haxe.ds.StringMap;
+import haxe.Constraints.IMap;
+
+/**
+ * A string map which treats any letter cases the same (case insensitive)
+ */
+class InsensitiveMap<T> implements IMap<String, T> {
+    var data:StringMap<T> = new StringMap();
+    var originalKeys:Map<String, String> = new Map();
+
+    public function new() {}
+
+    public function set(key:String, value:T):Void {
+      var lowerKey = key.toLowerCase();
+      if (data.exists(key)) {
+        trace('[WARNING] Key "$key" already exists and will be not be overwritten.');
+        return;
+      }
+
+      data.set(lowerKey, value);
+      originalKeys.set(lowerKey, key);
+    }
+
+    public inline function get(key:String):Null<T> {
+      return data.get(key.toLowerCase());
+    }
+
+    public inline function exists(key:String):Bool {
+      return data.exists(key.toLowerCase());
+    }
+
+    public function remove(key:String):Bool {
+      var lowerKey = key.toLowerCase();
+      originalKeys.remove(lowerKey);
+      return data.remove(lowerKey);
+    }
+
+    public function clear():Void {
+      data.clear();
+      originalKeys.clear();
+    }
+
+    public function copy():InsensitiveMap<T> {
+      var res = new InsensitiveMap();
+      res.data = data.copy();
+      res.originalKeys = originalKeys.copy();
+      return res;
+    }
+
+    public inline function keys():Iterator<String> {
+      return originalKeys.iterator();
+    }
+
+    public function keyValueIterator() {
+      return {
+        var it = originalKeys.keys();
+        return {
+            hasNext: function() return it.hasNext(),
+                next: function() {
+                var lowerKey = it.next();
+                var originalKey = originalKeys.get(lowerKey);
+                return { key: originalKey, value: data.get(lowerKey) };
+            }
+        };
+      };
+  }
+
+    public inline function iterator() {
+        return data.iterator();
+    }
+
+    public function toString():String {
+        var parts = [];
+        for (key in keys()) {
+            parts.push('$key => ${get(key)}');
+        }
+        return '{' + parts.join(', ') + '}';
+    }
+}

polymod/util/insensitive/InsensitiveString.hx

@@ -0,0 +1,35 @@
+package polymod.util.insensitive;
+
+using StringTools;
+
+/**
+ * A case-insensitive string. (NOTE: Doesn't work properly in containers (Map, Array, etc.))
+ */
+@:forward
+abstract InsensitiveString(String) from String to String {
+    public inline function new(s:String) {
+        this = s;
+    }
+
+    // Operators
+    @:op(A==B)
+    inline function eq(b:InsensitiveString):Bool
+      return this.toLowerCase() == b.toLowerCase();
+
+    @:op(A!=B)
+    inline function notEq(b:InsensitiveString):Bool
+      return this.toLowerCase() != b.toLowerCase();
+
+    // Overrides
+    public inline function startsWith(s:InsensitiveString):Bool
+      return this.toLowerCase().startsWith(s.toLowerCase());
+
+    public inline function endsWith(s:InsensitiveString):Bool
+      return this.toLowerCase().endsWith(s.toLowerCase());
+
+    public inline function indexOf(s:String, ?startIndex:Int):Int
+      return this.toLowerCase().indexOf(s.toLowerCase(), startIndex);
+
+    public inline function lastIndexOf(s:String, ?startIndex:Int):Int
+      return this.toLowerCase().lastIndexOf(s.toLowerCase(), startIndex);
+}

polymod/util/zip/ZipParser.hx

@@ -3,6 +3,7 @@ package polymod.util.zip;
 #if sys
 import haxe.ds.StringMap;
 import haxe.io.Bytes;
+import polymod.util.insensitive.InsensitiveMap;
 import sys.io.File;
 import sys.io.FileInput;
 
@@ -34,7 +35,7 @@ class ZipParser
 	 * The central directory records, as parsed from the central directory.
 	 * These contain metadata about each file in the archive.
 	 */
-	public var centralDirectoryRecords:StringMap<CentralDirectoryFileHeader>;
+	public var centralDirectoryRecords:InsensitiveMap<CentralDirectoryFileHeader>;
 
 	public function new(fileName:String)
 	{
@@ -68,7 +69,7 @@ class ZipParser
 	 */
 	function getAllCentralDirectoryHeaders():Void
 	{
-		this.centralDirectoryRecords = new StringMap();
+		this.centralDirectoryRecords = new InsensitiveMap();
 		fileHandle.seek(this.endOfCentralDirectoryRecord.cdrOffset, SeekBegin);
 		for (_ in 0...this.endOfCentralDirectoryRecord.cdrsTotal)
 		{