Merge pull request #1864 from comintern/next

Hosch250 · web-flow · commit 2c6a498b062c · 2016-06-17T20:17:05.000-05:00
Fixes the last of the (known) SmartIndenter issues inherited from VB6.
diff --git a/Rubberduck.SmartIndenter/AbsoluteCodeLine.cs b/Rubberduck.SmartIndenter/AbsoluteCodeLine.cs
@@ -199,7 +199,7 @@ private int MultipleCaseAdjustment()
 
         public string Indent(int indents, bool atProcStart, bool absolute = false)
         {
-            if (IsEmpty || (ContainsOnlyComment && !_settings.AlignCommentsWithCode))
+            if (IsEmpty || (ContainsOnlyComment && !_settings.AlignCommentsWithCode && !absolute))
             {
                 return Original;
             }
diff --git a/Rubberduck.SmartIndenter/LogicalCodeLine.cs b/Rubberduck.SmartIndenter/LogicalCodeLine.cs
@@ -112,20 +112,24 @@ public string Indented()
             var current = _lines.First().Indent(IndentationLevel, AtProcedureStart);
             var commentPos = string.IsNullOrEmpty(_lines.First().EndOfLineComment) ? 0 : current.Length - _lines.First().EndOfLineComment.Length;
             output.Add(current);
-            var alignment = FunctionAlign(current, true);
+            var alignment = FunctionAlign(current);
 
             foreach (var line in _lines.Skip(1))
             {
+                if (line.ContainsOnlyComment)
+                {
+                    commentPos = alignment;
+                }
                 if (commentPos > 0)
                 {
                     output.Add(line.Indent(commentPos, AtProcedureStart, true));
                     continue;
                 }
 
-                var operatorAdjust = _settings.IgnoreOperatorsInContinuations && OperatorIgnoreRegex.IsMatch(line.Original) ? 2 : 0;
+                var operatorAdjust = _settings.IgnoreOperatorsInContinuations && OperatorIgnoreRegex.IsMatch(line.Original) ? 2 : 0;              
                 current = line.Indent(Math.Max(alignment - operatorAdjust, 0), AtProcedureStart, true);
                 output.Add(current);
-                alignment = FunctionAlign(current, false);
+                alignment = FunctionAlign(current);
                 commentPos = string.IsNullOrEmpty(line.EndOfLineComment) ? 0 : current.Length - line.EndOfLineComment.Length;
             }
 
@@ -135,7 +139,7 @@ public string Indented()
         private static readonly Regex StartIgnoreRegex = new Regex(@"^(\d*\s)?\s*[LR]?Set\s|^(\d*\s)?\s*Let\s|^(\d*\s)?\s*(Public|Private)\sDeclare\s(Function|Sub)|^(\d*\s+)");
         private readonly Stack<AlignmentToken> _alignment = new Stack<AlignmentToken>();
 
-        private int FunctionAlign(string line, bool firstLine)
+        private int FunctionAlign(string line)
         {
             var stackPos = _alignment.Count;
 
@@ -246,7 +250,7 @@ private int FunctionAlign(string line, bool firstLine)
 
             if (fallback == 0 || fallback >= line.Length - 1)
             {
-                fallback = !_alignment.Any() && firstLine ? (_settings.IndentSpaces * 2) : 0;
+                fallback = !_alignment.Any() ? (_settings.IndentSpaces * 2) : 0;
             }
             else
             {
diff --git a/RubberduckTests/SmartIndenter/LineContinuationTests.cs b/RubberduckTests/SmartIndenter/LineContinuationTests.cs
@@ -484,7 +484,7 @@ public void ContinuationsInTypeDeclarationsWorks()
         }
 
         //https://github.com/rubberduck-vba/Rubberduck/issues/1287
-        [TestMethod, Ignore]    // Broken in VB6 SmartIndenter.
+        [TestMethod]        // Broken in VB6 SmartIndenter.
         [TestCategory("Indenter")]
         public void ContinuationsInProcedureDeclarationsWorks()
         {
@@ -510,26 +510,25 @@ public void ContinuationsInProcedureDeclarationsWorks()
                 "End Sub"
             };
 
-            //TODO: Not sure if this is what should be expected...
             var expected = new[]
             {
                 "Sub MySub()",
                 "    Dim x1 As Integer",
                 "    Dim _",
-                "    x2 _",
-                "    As Integer",
+                "        x2 _",
+                "        As Integer",
                 "    Dim x3 As _",
-                "    Integer",
+                "        Integer",
                 "    Dim x4 _",
-                "    As _",
-                "    Integer",
+                "        As _",
+                "        Integer",
                 "    Dim x5 As Integer: _",
-                "    Dim x6 As _",
-                "    Integer",
+                "        Dim x6 As _",
+                "        Integer",
                 "    Dim x7 As Integer _",
-                "    'Comment _",
-                "    as _",
-                "    integer",
+                "        'Comment _",
+                "        as _",
+                "        integer",
                 "End Sub"
             };
 
@@ -545,7 +544,7 @@ public void ContinuationsInProcedureDeclarationsWorks()
         }
 
         //https://github.com/rubberduck-vba/Rubberduck/issues/1287
-        [TestMethod, Ignore]    // Broken in VB6 SmartIndenter.
+        [TestMethod]        // Broken in VB6 SmartIndenter.
         [TestCategory("Indenter")]
         public void ContinuationsInProcedureDeclarationsNoCommentAlignWorks()
         {
@@ -571,26 +570,55 @@ public void ContinuationsInProcedureDeclarationsNoCommentAlignWorks()
                 "End Sub"
             };
 
-            //TODO: Not sure if this is what should be expected...
             var expected = new[]
             {
                 "Sub MySub()",
                 "    Dim x1 As Integer",
                 "    Dim _",
-                "    x2 _",
-                "    As Integer",
+                "        x2 _",
+                "        As Integer",
                 "    Dim x3 As _",
-                "    Integer",
+                "        Integer",
                 "    Dim x4 _",
-                "    As _",
-                "    Integer",
+                "        As _",
+                "        Integer",
                 "    Dim x5 As Integer: _",
-                "    Dim x6 As _",
-                "    Integer",
+                "        Dim x6 As _",
+                "        Integer",
                 "    Dim x7 As Integer _",
-                "'Comment _",
-                "as _",
-                "integer",
+                "        'Comment _",
+                "        as _",
+                "        integer",
+                "End Sub"
+            };
+
+            var indenter = new Indenter(null, () =>
+            {
+                var s = IndenterSettingsTests.GetMockIndenterSettings();
+                s.AlignCommentsWithCode = false;
+                s.IndentFirstDeclarationBlock = true;
+                return s;
+            });
+            var actual = indenter.Indent(code, string.Empty);
+            Assert.IsTrue(expected.SequenceEqual(actual));
+        }
+
+        [TestMethod]
+        public void ContinuationWithOnlyCommentWorks()
+        {
+            var code = new[]
+            {
+                "Sub MySub()",
+                "Debug.Print Foo _",
+                "'Is this and end of line comment or not...?",
+                "End Sub"
+            };
+
+            var expected = new[]
+            {
+                "Sub MySub()",
+                "    Debug.Print Foo _",
+                "                'Is this and end of line comment or not...?",
                 "End Sub"
             };
 

Original file line number	Diff line number	Diff line change
`@@ -199,7 +199,7 @@ private int MultipleCaseAdjustment()`
`199`	`199`
`200`	`200`	`public string Indent(int indents, bool atProcStart, bool absolute = false)`
`201`	`201`	`{`
`202`		`- if (IsEmpty \|\| (ContainsOnlyComment && !_settings.AlignCommentsWithCode))`
	`202`	`+ if (IsEmpty \|\| (ContainsOnlyComment && !_settings.AlignCommentsWithCode && !absolute))`
`203`	`203`	`{`
`204`	`204`	`return Original;`
`205`	`205`	`}`
Original file line number	Diff line number	Diff line change
`@@ -112,20 +112,24 @@ public string Indented()`
`112`	`112`	`var current = _lines.First().Indent(IndentationLevel, AtProcedureStart);`
`113`	`113`	`var commentPos = string.IsNullOrEmpty(_lines.First().EndOfLineComment) ? 0 : current.Length - _lines.First().EndOfLineComment.Length;`
`114`	`114`	`output.Add(current);`
`115`		`- var alignment = FunctionAlign(current, true);`
	`115`	`+ var alignment = FunctionAlign(current);`
`116`	`116`
`117`	`117`	`foreach (var line in _lines.Skip(1))`
`118`	`118`	`{`
	`119`	`+ if (line.ContainsOnlyComment)`
	`120`	`+ {`
	`121`	`+ commentPos = alignment;`
	`122`	`+ }`
`119`	`123`	`if (commentPos > 0)`
`120`	`124`	`{`
`121`	`125`	`output.Add(line.Indent(commentPos, AtProcedureStart, true));`
`122`	`126`	`continue;`
`123`	`127`	`}`
`124`	`128`
`125`		`- var operatorAdjust = _settings.IgnoreOperatorsInContinuations && OperatorIgnoreRegex.IsMatch(line.Original) ? 2 : 0;`
	`129`	`+ var operatorAdjust = _settings.IgnoreOperatorsInContinuations && OperatorIgnoreRegex.IsMatch(line.Original) ? 2 : 0;`
`126`	`130`	`current = line.Indent(Math.Max(alignment - operatorAdjust, 0), AtProcedureStart, true);`
`127`	`131`	`output.Add(current);`
`128`		`- alignment = FunctionAlign(current, false);`
	`132`	`+ alignment = FunctionAlign(current);`
`129`	`133`	`commentPos = string.IsNullOrEmpty(line.EndOfLineComment) ? 0 : current.Length - line.EndOfLineComment.Length;`
`130`	`134`	`}`
`131`	`135`
`@@ -135,7 +139,7 @@ public string Indented()`
`135`	`139`	`private static readonly Regex StartIgnoreRegex = new Regex(@"^(\d\s)?\s[LR]?Set\s\|^(\d\s)?\sLet\s\|^(\d\s)?\s(Public\|Private)\sDeclare\s(Function\|Sub)\|^(\d*\s+)");`
`136`	`140`	`private readonly Stack<AlignmentToken> _alignment = new Stack<AlignmentToken>();`
`137`	`141`
`138`		`- private int FunctionAlign(string line, bool firstLine)`
	`142`	`+ private int FunctionAlign(string line)`
`139`	`143`	`{`
`140`	`144`	`var stackPos = _alignment.Count;`
`141`	`145`
`@@ -246,7 +250,7 @@ private int FunctionAlign(string line, bool firstLine)`
`246`	`250`
`247`	`251`	`if (fallback == 0 \|\| fallback >= line.Length - 1)`
`248`	`252`	`{`
`249`		`- fallback = !_alignment.Any() && firstLine ? (_settings.IndentSpaces * 2) : 0;`
	`253`	`+ fallback = !_alignment.Any() ? (_settings.IndentSpaces * 2) : 0;`
`250`	`254`	`}`
`251`	`255`	`else`
`252`	`256`	`{`