", 22));
91 | Assert.IsFalse(SparkSyntax.IsPositionInAttributeName("", 22));
92 | }
93 | }
94 | }
95 |
--------------------------------------------------------------------------------
/src/SparkSense.Tests/Parsing/WhenParsingIncompleteCode.cs:
--------------------------------------------------------------------------------
1 | using NUnit.Framework;
2 | using Spark.Parser.Markup;
3 | using SparkSense.Tests.Scenarios;
4 |
5 | namespace SparkSense.Tests.Parsing
6 | {
7 | public class WhenParsingIncompleteCode : SyntaxParsingScenario
8 | {
9 | [Test]
10 | public void ShouldCorrectlyParseIncompleteCodeAfterBangSyntax()
11 | {
12 | GivenSomeContentToParse("!{user.");
13 | WhenParsingForIncompleteCode();
14 | TheParsedExpressionNode
15 | .ShouldNotBeNull()
16 | .ShouldBeOfType()
17 | .Code.ToString()
18 | .ShouldBe("user.");
19 | }
20 |
21 | [Test]
22 | public void ShouldCorrectlyParseIncompleteCodeAfterDollarSyntax()
23 | {
24 | GivenSomeContentToParse("${user.");
25 | WhenParsingForIncompleteCode();
26 | TheParsedExpressionNode
27 | .ShouldNotBeNull()
28 | .ShouldBeOfType()
29 | .Code.ToString()
30 | .ShouldBe("user.");
31 | }
32 |
33 | [Test]
34 | public void ShouldCorrectlyParseIncompleteCodeWhenFollowedByAnotherNode()
35 | {
36 | GivenSomeContentToParse("${user.name
");
37 | WhenParsingForAnyNode();
38 | TheParsedExpressionNode
39 | .ShouldNotBeNull()
40 | .ShouldBeOfType()
41 | .Code.ToString()
42 | .ShouldBe("user.name");
43 | }
44 | }
45 | }
--------------------------------------------------------------------------------
/src/SparkSense.Tests/Properties/AssemblyInfo.cs:
--------------------------------------------------------------------------------
1 | using System.Reflection;
2 | using System.Runtime.InteropServices;
3 |
4 | // General Information about an assembly is controlled through the following
5 | // set of attributes. Change these attribute values to modify the information
6 | // associated with an assembly.
7 | [assembly: AssemblyTitle("SparkSense.Tests")]
8 | [assembly: AssemblyDescription("")]
9 | [assembly: AssemblyConfiguration("")]
10 | [assembly: AssemblyCompany("Microsoft")]
11 | [assembly: AssemblyProduct("SparkSense.Tests")]
12 | [assembly: AssemblyCopyright("Copyright © Microsoft 2010")]
13 | [assembly: AssemblyTrademark("")]
14 | [assembly: AssemblyCulture("")]
15 |
16 | // Setting ComVisible to false makes the types in this assembly not visible
17 | // to COM components. If you need to access a type in this assembly from
18 | // COM, set the ComVisible attribute to true on that type.
19 | [assembly: ComVisible(false)]
20 |
21 | // The following GUID is for the ID of the typelib if this project is exposed to COM
22 | [assembly: Guid("96696988-fba0-4e6c-bf1f-c807ec005efe")]
23 |
24 | // Version information for an assembly consists of the following four values:
25 | //
26 | // Major Version
27 | // Minor Version
28 | // Build Number
29 | // Revision
30 | //
31 | // You can specify all the values or you can default the Build and Revision Numbers
32 | // by using the '*' as shown below:
33 | // [assembly: AssemblyVersion("1.0.*")]
34 | [assembly: AssemblyVersion("1.0.0.0")]
35 | [assembly: AssemblyFileVersion("1.0.0.0")]
36 |
--------------------------------------------------------------------------------
/src/SparkSense.Tests/Scenarios/Scenario.cs:
--------------------------------------------------------------------------------
1 | using NUnit.Framework;
2 |
3 | namespace SparkSense.Tests.Scenarios
4 | {
5 | [TestFixture]
6 | public class Scenario
7 | {
8 | #region Setup/Teardown
9 |
10 | [SetUp]
11 | protected virtual void SetUp()
12 | {
13 | }
14 |
15 | [TearDown]
16 | protected virtual void TearDown()
17 | {
18 | }
19 |
20 | #endregion
21 |
22 | [Test]
23 | public void ShouldNotBeIgnoredByTestRunner() { }
24 | }
25 | }
--------------------------------------------------------------------------------
/src/SparkSense.Tests/Scenarios/SyntaxCompilationScenario.cs:
--------------------------------------------------------------------------------
1 | using System.Collections.Generic;
2 | using Spark.Compiler;
3 | using Spark.Compiler.NodeVisitors;
4 | using Spark.FileSystem;
5 | using SparkSense.Parser;
6 |
7 | namespace SparkSense.Tests.Scenarios
8 | {
9 | public class SyntaxCompilationScenario : Scenario
10 | {
11 | private CompletionSyntaxProvider _syntaxProvider;
12 | private VisitorContext _context;
13 |
14 | protected IList TheParsedChunks { get; private set; }
15 |
16 | protected void GivenSomeContentToCompile(string content)
17 | {
18 | _syntaxProvider = new CompletionSyntaxProvider();
19 | _context = new VisitorContext
20 | {ViewFolder = new InMemoryViewFolder {{"Home\\index.spark", @"${user.
"}}};
21 | }
22 |
23 | protected void WhenCompilingIntoCodeSnippitChunks()
24 | {
25 | TheParsedChunks = _syntaxProvider.GetChunks(_context, "Home\\index.spark");
26 | }
27 | }
28 | }
--------------------------------------------------------------------------------
/src/SparkSense.Tests/Scenarios/SyntaxParsingScenario.cs:
--------------------------------------------------------------------------------
1 | using Spark.Parser;
2 | using Spark.Parser.Markup;
3 | using SparkSense.Parser;
4 |
5 | namespace SparkSense.Tests.Scenarios
6 | {
7 | public class SyntaxParsingScenario : Scenario
8 | {
9 | private CompletionGrammar _grammar;
10 | private Position _sourceContent;
11 | protected ExpressionNode TheParsedExpressionNode { get; private set; }
12 |
13 | protected Position Source(string content)
14 | {
15 | return new Position(new SourceContext(content));
16 | }
17 |
18 | protected void GivenSomeContentToParse(string content)
19 | {
20 | _grammar = new CompletionGrammar();
21 | _sourceContent = Source(content);
22 | }
23 |
24 | protected void WhenParsingForAnyNode()
25 | {
26 | TheParsedExpressionNode = _grammar.AnyNode(_sourceContent).Value as ExpressionNode;
27 | }
28 |
29 | protected void WhenParsingForIncompleteCode()
30 | {
31 | TheParsedExpressionNode = null;
32 | ParseResult result = _grammar.IncompleteCode(_sourceContent);
33 | TheParsedExpressionNode = result == null ? null : result.Value;
34 | }
35 | }
36 | }
--------------------------------------------------------------------------------
/src/SparkSense.Tests/Scenarios/TypeCompletionScenario.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using Microsoft.VisualStudio.Language.Intellisense;
4 | using SparkSense.Parser;
5 | using SparkSense.Parsing;
6 |
7 | namespace SparkSense.Tests.Scenarios
8 | {
9 | public class TypeCompletionScenario : TypeResolutionScenario
10 | {
11 | protected IEnumerable TheCompletionList { get; private set; }
12 |
13 | protected void WhenTriggeringAnInitialCompletion()
14 | {
15 | WhenTriggeringACompletion(string.Empty);
16 | }
17 |
18 | protected void WhenTriggeringACompletion(string codeSnippit)
19 | {
20 | var completionBuilder = new CompletionBuilder(TheViewExplorer);
21 | WhenLookingUpTriggerTypes();
22 | TheCompletionList = completionBuilder.ToCompletionList(codeSnippit);
23 | }
24 | }
25 | }
--------------------------------------------------------------------------------
/src/SparkSense.Tests/Scenarios/TypeResolutionScenario.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections;
3 | using System.Collections.Generic;
4 | using System.ComponentModel.Design;
5 | using System.Reflection;
6 | using Rhino.Mocks;
7 | using SparkSense.Parsing;
8 |
9 | namespace SparkSense.Tests.Scenarios
10 | {
11 | public class TypeResolutionScenario : Scenario
12 | {
13 | protected Type TheResolvedType { get; private set; }
14 |
15 | protected IEnumerable TheResolvedTriggerTypes { get; private set; }
16 |
17 | protected IEnumerable TheResolvedMembers { get; private set; }
18 |
19 | protected IEnumerable TheResolvedMethods { get; private set; }
20 |
21 | protected string TheRemainingCode { get; private set; }
22 |
23 | public TypeNavigator TheTypeNavigator { get; private set; }
24 |
25 | protected IViewExplorer TheViewExplorer { get; set; }
26 |
27 | protected void GivenReferencedTypes(IEnumerable types)
28 | {
29 | TheTypeNavigator = new TypeNavigator(types);
30 | TheViewExplorer = MockRepository.GenerateMock();
31 | TheViewExplorer.Expect(x => x.GetTypeNavigator()).Return(TheTypeNavigator);
32 | TheViewExplorer.Expect(x => x.GetLocalVariableChunks()).Return(null);
33 | TheViewExplorer.Expect(x => x.GetViewDataVariableChunks()).Return(null);
34 | }
35 |
36 | protected void WhenLookingUpTriggerTypes()
37 | {
38 | TheResolvedTriggerTypes = TheTypeNavigator.GetTriggerTypes();
39 | }
40 |
41 | protected void WhenLookingUpStaticMembers()
42 | {
43 | TheResolvedMembers = TheTypeNavigator.GetStaticMembers();
44 | }
45 |
46 | protected void WhenLookingUpInstanceMembers()
47 | {
48 | TheResolvedMembers = TheTypeNavigator.GetInstanceMembers();
49 | }
50 |
51 | protected void WhenLookingUpMethods(string methodName)
52 | {
53 | TheResolvedMethods = TheTypeNavigator.GetMethodByName(methodName);
54 | }
55 |
56 | protected void WhenLookingUpSomeCode(string codeSnippit)
57 | {
58 | Type resolvedType;
59 | string remainingCode;
60 | if (TheTypeNavigator.TryResolveType(TheViewExplorer, codeSnippit, out resolvedType, out remainingCode))
61 | TheResolvedType = resolvedType;
62 | TheRemainingCode = remainingCode;
63 | }
64 |
65 | protected class StubPrivateType
66 | {
67 | public string StubInstanceField;
68 |
69 | public string StubInstanceProperty { get; set; }
70 |
71 | public string StubInstanceMethod()
72 | {
73 | return string.Empty;
74 | }
75 | }
76 |
77 | public class StubTypeWithNoStatics
78 | {
79 | public string StubInstanceField;
80 |
81 | public string StubInstanceProperty { get; set; }
82 |
83 | public string StubInstanceMethod()
84 | {
85 | return string.Empty;
86 | }
87 | }
88 |
89 | public class StubType
90 | {
91 | public static string StubStaticField;
92 |
93 | public string StubInstanceField;
94 |
95 | public static string StubStaticProperty { get; set; }
96 |
97 | public string StubInstanceProperty { get; set; }
98 |
99 | public StubType StubTypeInstanceProperty { get; set; }
100 |
101 | public static string StubStaticMethod()
102 | {
103 | return string.Empty;
104 | }
105 |
106 | public string StubInstanceMethod()
107 | {
108 | return string.Empty;
109 | }
110 |
111 | public string StubMethodWithParameters(string param1)
112 | {
113 | return string.Empty;
114 | }
115 |
116 | public string StubMethodWithParameters(string param1, int param2)
117 | {
118 | return string.Empty;
119 | }
120 |
121 | public string StubMethodWithParameters(string param1, int param2, StubType param3)
122 | {
123 | return string.Empty;
124 | }
125 | }
126 | }
127 | }
--------------------------------------------------------------------------------
/src/SparkSense.Tests/SparkSense.Tests.Views/Shared/Application.spark:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | ${title}
5 |
6 |
7 |
12 |
13 |
14 |
15 |
20 |
21 |
22 |
--------------------------------------------------------------------------------
/src/SparkSense.Tests/SparkSense.Tests.Views/Shared/_SharedPartial.spark:
--------------------------------------------------------------------------------
1 | Some shared content
--------------------------------------------------------------------------------
/src/SparkSense.Tests/SparkSense.Tests.Views/Shared/test.spark:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 | | Name |
14 | Type |
15 |
16 |
17 | | ${user.Name} |
18 | ${user.UserType} |
19 |
20 |
21 |