Merge pull request #1028 from fdorg/organize-imports-better-sort

Organize/insert imports better sort

Author: elsassph

External/Plugins/ASCompletion/Completion/ASGenerator.cs

@@ -4219,7 +4219,8 @@ public static int InsertImport(MemberModel member, bool fixScrolling)
             string txt;
             int indent = 0;
             int skipIfDef = 0;
-            Match mImport;
+            Match mImport;
+            var importComparer = new CaseSensitiveImportComparer();
             while (line < curLine)
             {
                 txt = sci.GetLine(line++).TrimStart();
@@ -4236,15 +4237,14 @@ public static int InsertImport(MemberModel member, bool fixScrolling)
                     else continue;
                 }
                 // insert imports after a package declaration
-                else if (txt.StartsWith("import"))
+                else if (txt.Length > 6 && txt.StartsWith("import") && txt[6] <= 32)
                 {
                     packageLine = -1;
                     found = true;
                     indent = sci.GetLineIndentation(line - 1);
                     // insert in alphabetical order
                     mImport = ASFileParserRegexes.Import.Match(txt);
-                    if (mImport.Success &&
-                        String.Compare(mImport.Groups["package"].Value, fullPath) > 0)
+                    if (mImport.Success && importComparer.Compare(mImport.Groups["package"].Value, fullPath) > 0)
                     {
                         line--;
                         break;

External/Plugins/ASCompletion/Model/MemberModel.cs

@@ -538,4 +538,98 @@ public int Compare(MemberModel a, MemberModel b)
         }
 
     }
+
+    /// <summary>
+    /// Compare members based on import name
+    /// </summary>
+    public class CaseSensitiveImportComparer : IComparer<MemberModel>
+    {
+        static Int32 GetPackageTypeSeparation(string import)
+        {
+            var dot = import.IndexOf('.');
+            var lastDot = -1;
+            var max = import.Length - 1;
+            while (dot > 0 && dot < max)
+            {
+                if (Char.IsUpper(import[dot + 1]))
+                    return dot;
+                lastDot = dot;
+                dot = import.IndexOf('.', dot + 1);
+            }
+            if (dot < 0 || dot >= max) return lastDot;
+            else if (dot == 0) return -1;
+            else return dot;
+        }
+
+        public static Int32 CompareImports(string import1, string import2)
+        {
+            IComparer cmp = StringComparer.Ordinal;
+            var d1 = GetPackageTypeSeparation(import1);
+            var d2 = GetPackageTypeSeparation(import2);
+            // one or both imports do not have a package
+            if (d1 < 0) 
+            {
+                if (d2 > 0) return -1;
+                else return cmp.Compare(import1, import2);
+            }
+            else if (d2 < 0) 
+            {
+                if (d1 > 0) return 1;
+                else return cmp.Compare(import1, import2);
+            }
+            // compare package
+            var pkg1 = import1.Substring(0, d1);
+            var pkg2 = import2.Substring(0, d2);
+            var res = cmp.Compare(pkg1, pkg2);
+            if (res != 0) return res;
+            // compare type
+            var tp1 = import1.Substring(d1 + 1);
+            var tp2 = import2.Substring(d2 + 1);
+            res = cmp.Compare(tp1, tp2);
+            return res;
+        }
+
+#if DEBUG 
+        static void Assert(int res, int expected)
+        {
+            System.Diagnostics.Debug.Assert(res == expected, res + " was not expected " + expected);
+        }
+
+        static CaseSensitiveImportComparer()
+        {
+            // poor man's unit tests
+            Assert(GetPackageTypeSeparation("a.b.C"), 3);
+            Assert(GetPackageTypeSeparation("a.b.c"), 3);
+            Assert(GetPackageTypeSeparation("a.b.C.D"), 3);
+            Assert(GetPackageTypeSeparation("a"), -1);
+            Assert(GetPackageTypeSeparation(".a"), -1);
+            Assert(GetPackageTypeSeparation("a."), -1);
+            Assert(GetPackageTypeSeparation("a.b.c."), 3);
+
+            Assert(CompareImports("a", "A"), 32);
+            Assert(CompareImports("a", "b"), -1);
+            Assert(CompareImports("b", "a"), 1);
+            Assert(CompareImports("a", "a"), 0);
+            Assert(CompareImports("a.A", "b"), 1);
+            Assert(CompareImports("a", "b.B"), -1);
+            Assert(CompareImports("a.A", "b.A"), -1);
+            Assert(CompareImports("b.A", "a.A"), 1);
+            Assert(CompareImports("a.A", "a.A"), 0);
+            Assert(CompareImports("a.A", "a.B"), -1);
+            Assert(CompareImports("b.A", "a.A"), 1);
+            Assert(CompareImports("a.A", "a.a"), -32);
+            Assert(CompareImports("a.MathReal", "a.Mathematics"), -19);
+        }
+#endif
+
+        public Int32 Compare(string import1, string import2)
+        {
+            return CompareImports(import1, import2);
+        }
+
+        public Int32 Compare(MemberModel item1, MemberModel item2)
+        {
+            return CompareImports(item1.Type, item2.Type);
+        }
+    }
 }

External/Plugins/CodeRefactor/Commands/OrganizeImports.cs

@@ -149,8 +149,7 @@ private void InsertImports(List<MemberModel> imports, String searchInText, Scint
         {
             String eol = LineEndDetector.GetNewLineMarker(sci.EOLMode);
             Int32 line = imports[0].LineFrom - DeletedImportsCompensation;
-            ImportsComparerType comparerType = new ImportsComparerType();
-            imports.Sort(comparerType);
+            imports.Sort(new CaseSensitiveImportComparer());
             sci.GotoLine(line);
             Int32 curLine = 0;
             List<String> uniques = this.GetUniqueImports(imports, searchInText, sci.FileName);
@@ -219,17 +218,6 @@ public override Boolean IsValid()
 
     }
 
-    /// <summary>
-    /// Compare import statements based on import name
-    /// </summary>
-    class ImportsComparerType : IComparer<MemberModel>
-    {
-        public Int32 Compare(MemberModel item1, MemberModel item2)
-        {
-            return new CaseInsensitiveComparer().Compare(item1.Type, item2.Type);
-        }
-    }
-
     /// <summary>
     /// Compare import statements based on declaration line
     /// </summary>