toCompile, CompilerOptions opt)
73 | {
74 | foreach (var sourcePath in toCompile)
75 | {
76 | string result = Compile(sourcePath, opt);
77 |
78 | if (opt.Print)
79 | Console.WriteLine(result);
80 | else
81 | {
82 | string dest;
83 | dest = opt.OutputDir.IsNullOrWhiteSpace() ?
84 | sourcePath
85 | : sourcePath.Replace(opt.Path, opt.OutputDir);
86 |
87 | dest = Path.ChangeExtension(dest, ".js");
88 | var destDir = new FileInfo(dest).Directory;
89 | if(!destDir.Exists)
90 | {
91 | destDir.Create();
92 | }
93 |
94 | File.WriteAllText(dest, result, Encoding.UTF8);
95 | }
96 | }
97 | }
98 |
99 | private static string Compile(string sourcePath, CompilerOptions opt)
100 | {
101 | //ugly hack. When triggered by the filesystemwatcher (--watch mode), the file may be transiently locked
102 | //by another process, and the call to Read would throw. Trying to monitor this in procmon I found at least
103 | //three background processes happily opening the file. We should poll and check locking beforehand, but this
104 | //will do for now. Wow, that's a big comment/code ratio.
105 | Thread.Sleep(100);
106 |
107 | var source = File.ReadAllText(sourcePath, Encoding.UTF8);
108 | string result = "";
109 | try
110 | {
111 | result = CoffeeScriptProcessor.Process(source, opt.Bare);
112 | }
113 | catch (Exception ex)
114 | {
115 | Console.WriteLine("Error while compiling " + sourcePath + " :");
116 | Console.WriteLine(ex.Message);
117 | }
118 | return result;
119 | }
120 | }
121 | }
--------------------------------------------------------------------------------
/CoffeeScript.Compiler.sln:
--------------------------------------------------------------------------------
1 |
2 | Microsoft Visual Studio Solution File, Format Version 11.00
3 | # Visual Studio 2010
4 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CoffeeScript.Compiler.Web", "CoffeeScript.Compiler.Web\CoffeeScript.Compiler.Web.csproj", "{6B612CBC-F6AD-498E-83AF-485C1AE97A93}"
5 | EndProject
6 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CoffeeScript.Compiler", "CoffeeScript.Compiler\CoffeeScript.Compiler.csproj", "{699F78A5-E1E7-4FB5-BC55-FA62E3A6A095}"
7 | EndProject
8 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ncoffee", "ncoffee\ncoffee.csproj", "{A56A1CFA-4D79-40D2-BB50-91BB018BDC62}"
9 | EndProject
10 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CoffeeScript.Compiler.Tests", "CoffeeScript.Compiler.Tests\CoffeeScript.Compiler.Tests.csproj", "{DE90C81F-AA9C-4DCB-B1EB-2F94FCEA8E74}"
11 | EndProject
12 | Global
13 | GlobalSection(SolutionConfigurationPlatforms) = preSolution
14 | Debug|Any CPU = Debug|Any CPU
15 | Debug|Mixed Platforms = Debug|Mixed Platforms
16 | Debug|x86 = Debug|x86
17 | Release|Any CPU = Release|Any CPU
18 | Release|Mixed Platforms = Release|Mixed Platforms
19 | Release|x86 = Release|x86
20 | EndGlobalSection
21 | GlobalSection(ProjectConfigurationPlatforms) = postSolution
22 | {6B612CBC-F6AD-498E-83AF-485C1AE97A93}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
23 | {6B612CBC-F6AD-498E-83AF-485C1AE97A93}.Debug|Any CPU.Build.0 = Debug|Any CPU
24 | {6B612CBC-F6AD-498E-83AF-485C1AE97A93}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
25 | {6B612CBC-F6AD-498E-83AF-485C1AE97A93}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
26 | {6B612CBC-F6AD-498E-83AF-485C1AE97A93}.Debug|x86.ActiveCfg = Debug|Any CPU
27 | {6B612CBC-F6AD-498E-83AF-485C1AE97A93}.Release|Any CPU.ActiveCfg = Release|Any CPU
28 | {6B612CBC-F6AD-498E-83AF-485C1AE97A93}.Release|Any CPU.Build.0 = Release|Any CPU
29 | {6B612CBC-F6AD-498E-83AF-485C1AE97A93}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
30 | {6B612CBC-F6AD-498E-83AF-485C1AE97A93}.Release|Mixed Platforms.Build.0 = Release|Any CPU
31 | {6B612CBC-F6AD-498E-83AF-485C1AE97A93}.Release|x86.ActiveCfg = Release|Any CPU
32 | {699F78A5-E1E7-4FB5-BC55-FA62E3A6A095}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
33 | {699F78A5-E1E7-4FB5-BC55-FA62E3A6A095}.Debug|Any CPU.Build.0 = Debug|Any CPU
34 | {699F78A5-E1E7-4FB5-BC55-FA62E3A6A095}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
35 | {699F78A5-E1E7-4FB5-BC55-FA62E3A6A095}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
36 | {699F78A5-E1E7-4FB5-BC55-FA62E3A6A095}.Debug|x86.ActiveCfg = Debug|Any CPU
37 | {699F78A5-E1E7-4FB5-BC55-FA62E3A6A095}.Release|Any CPU.ActiveCfg = Release|Any CPU
38 | {699F78A5-E1E7-4FB5-BC55-FA62E3A6A095}.Release|Any CPU.Build.0 = Release|Any CPU
39 | {699F78A5-E1E7-4FB5-BC55-FA62E3A6A095}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
40 | {699F78A5-E1E7-4FB5-BC55-FA62E3A6A095}.Release|Mixed Platforms.Build.0 = Release|Any CPU
41 | {699F78A5-E1E7-4FB5-BC55-FA62E3A6A095}.Release|x86.ActiveCfg = Release|Any CPU
42 | {A56A1CFA-4D79-40D2-BB50-91BB018BDC62}.Debug|Any CPU.ActiveCfg = Debug|x86
43 | {A56A1CFA-4D79-40D2-BB50-91BB018BDC62}.Debug|Mixed Platforms.ActiveCfg = Debug|x86
44 | {A56A1CFA-4D79-40D2-BB50-91BB018BDC62}.Debug|Mixed Platforms.Build.0 = Debug|x86
45 | {A56A1CFA-4D79-40D2-BB50-91BB018BDC62}.Debug|x86.ActiveCfg = Debug|x86
46 | {A56A1CFA-4D79-40D2-BB50-91BB018BDC62}.Debug|x86.Build.0 = Debug|x86
47 | {A56A1CFA-4D79-40D2-BB50-91BB018BDC62}.Release|Any CPU.ActiveCfg = Release|x86
48 | {A56A1CFA-4D79-40D2-BB50-91BB018BDC62}.Release|Mixed Platforms.ActiveCfg = Release|x86
49 | {A56A1CFA-4D79-40D2-BB50-91BB018BDC62}.Release|Mixed Platforms.Build.0 = Release|x86
50 | {A56A1CFA-4D79-40D2-BB50-91BB018BDC62}.Release|x86.ActiveCfg = Release|x86
51 | {A56A1CFA-4D79-40D2-BB50-91BB018BDC62}.Release|x86.Build.0 = Release|x86
52 | {DE90C81F-AA9C-4DCB-B1EB-2F94FCEA8E74}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
53 | {DE90C81F-AA9C-4DCB-B1EB-2F94FCEA8E74}.Debug|Any CPU.Build.0 = Debug|Any CPU
54 | {DE90C81F-AA9C-4DCB-B1EB-2F94FCEA8E74}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
55 | {DE90C81F-AA9C-4DCB-B1EB-2F94FCEA8E74}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
56 | {DE90C81F-AA9C-4DCB-B1EB-2F94FCEA8E74}.Debug|x86.ActiveCfg = Debug|Any CPU
57 | {DE90C81F-AA9C-4DCB-B1EB-2F94FCEA8E74}.Release|Any CPU.ActiveCfg = Release|Any CPU
58 | {DE90C81F-AA9C-4DCB-B1EB-2F94FCEA8E74}.Release|Any CPU.Build.0 = Release|Any CPU
59 | {DE90C81F-AA9C-4DCB-B1EB-2F94FCEA8E74}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
60 | {DE90C81F-AA9C-4DCB-B1EB-2F94FCEA8E74}.Release|Mixed Platforms.Build.0 = Release|Any CPU
61 | {DE90C81F-AA9C-4DCB-B1EB-2F94FCEA8E74}.Release|x86.ActiveCfg = Release|Any CPU
62 | EndGlobalSection
63 | GlobalSection(SolutionProperties) = preSolution
64 | HideSolutionNode = FALSE
65 | EndGlobalSection
66 | EndGlobal
67 |
--------------------------------------------------------------------------------
/CoffeeScript.Compiler.Tests/CoffeeScript.Compiler.Tests.csproj:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | Debug
5 | AnyCPU
6 | 8.0.30703
7 | 2.0
8 | {DE90C81F-AA9C-4DCB-B1EB-2F94FCEA8E74}
9 | Library
10 | Properties
11 | CoffeeScript.Compiler.Tests
12 | CoffeeScript.Compiler.Tests
13 | v3.5
14 | 512
15 |
16 |
17 |
18 | true
19 | full
20 | false
21 | bin\Debug\
22 | DEBUG;TRACE
23 | prompt
24 | 4
25 | AnyCPU
26 |
27 |
28 | pdbonly
29 | true
30 | bin\Release\
31 | TRACE
32 | prompt
33 | 4
34 | x86
35 |
36 |
37 |
38 | ..\Lib\Irony.dll
39 |
40 |
41 | ..\packages\NUnit.2.5.9.10348\lib\nunit.framework.dll
42 |
43 |
44 | ..\packages\NUnit.2.5.9.10348\lib\nunit.mocks.dll
45 |
46 |
47 | ..\packages\NUnit.2.5.9.10348\lib\pnunit.framework.dll
48 |
49 |
50 |
51 |
52 |
53 |
54 |
55 |
56 |
57 |
58 |
59 |
60 |
61 |
62 |
63 |
64 |
65 |
66 |
67 |
68 |
69 |
70 |
71 |
72 |
73 |
74 |
75 |
76 |
77 |
78 | PreserveNewest
79 |
80 |
81 |
82 |
83 |
84 |
85 |
86 |
87 | {699F78A5-E1E7-4FB5-BC55-FA62E3A6A095}
88 | CoffeeScript.Compiler
89 |
90 |
91 |
92 |
99 |
--------------------------------------------------------------------------------
/CoffeeScript.Compiler.Web/CoffeeScript.Compiler.Web.csproj:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | Debug
5 | AnyCPU
6 |
7 |
8 | 2.0
9 | {6B612CBC-F6AD-498E-83AF-485C1AE97A93}
10 | {E53F8FEA-EAE0-44A6-8774-FFD645390401};{349c5851-65df-11da-9384-00065b846f21};{fae04ec0-301f-11d3-bf4b-00c04f79efbc}
11 | Library
12 | Properties
13 | CoffeeScript.Compiler.Web
14 | CoffeeScript.Compiler.Web
15 | v4.0
16 | false
17 | \Scripts\coffeescript.js
18 |
19 |
20 | true
21 | full
22 | false
23 | bin\
24 | DEBUG;TRACE
25 | prompt
26 | 4
27 | AnyCPU
28 |
29 |
30 | pdbonly
31 | true
32 | bin\
33 | TRACE
34 | prompt
35 | 4
36 |
37 |
38 |
39 | ..\Lib\Jurassic.dll
40 |
41 |
42 |
43 |
44 |
45 |
46 |
47 |
48 |
49 |
50 |
51 |
52 |
53 |
54 |
55 |
56 |
57 |
58 |
59 |
60 |
61 |
62 |
63 |
64 |
65 |
66 |
67 | Global.asax
68 |
69 |
70 |
71 |
72 |
73 |
74 |
75 | Web.config
76 |
77 |
78 | Web.config
79 |
80 |
81 |
82 |
83 |
84 |
85 |
86 |
87 |
88 |
89 |
90 |
91 |
92 |
93 |
94 |
95 |
96 |
97 |
98 | {699F78A5-E1E7-4FB5-BC55-FA62E3A6A095}
99 | CoffeeScript.Compiler
100 |
101 |
102 |
103 |
104 |
110 |
111 |
112 |
113 |
114 |
115 |
116 |
117 | False
118 | True
119 | 50656
120 | /
121 | http://localhost/CoffeeScript.Compiler.Web
122 | False
123 | False
124 |
125 |
126 | False
127 |
128 |
129 |
130 |
131 |
--------------------------------------------------------------------------------
/packages/NUnit.2.5.9.10348/NUnitFitTests.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | NUnit Acceptance Tests
5 |
6 | Developers love self-referential programs! Hence, NUnit has always run all it's
7 | own tests, even those that are not really unit tests.
8 |
Now, beginning with NUnit 2.4, NUnit has top-level tests using Ward Cunningham's
9 | FIT framework. At this time, the tests are pretty rudimentary, but it's a start
10 | and it's a framework for doing more.
11 |
Running the Tests
12 | Open a console or shell window and navigate to the NUnit bin directory, which
13 | contains this file. To run the test under Microsoft .Net, enter the command
14 |
runFile NUnitFitTests.html TestResults.html .
15 | To run it under Mono, enter
16 | mono runFile.exe NUnitFitTests.html TestResults.html .
17 | Note the space and dot at the end of each command. The results of your test
18 | will be in TestResults.html in the same directory.
19 | Platform and CLR Version
20 |
21 |
22 | | NUnit.Fixtures.PlatformInfo |
23 |
24 |
25 | Verify Unit Tests
26 |
27 | Load and run the NUnit unit tests, verifying that the results are as expected.
28 | When these tests are run on different platforms, different numbers of tests may
29 | be skipped, so the values for Skipped and Run tests are informational only.
30 |
31 | The number of tests in each assembly should be constant across all platforms -
32 | any discrepancy usually means that one of the test source files was not
33 | compiled on the platform. There should be no failures and no tests ignored.
34 |
Note:
35 | At the moment, the nunit.extensions.tests assembly is failing because the
36 | fixture doesn't initialize addins in the test domain.
37 |
38 |
39 |
40 | | NUnit.Fixtures.AssemblyRunner |
41 |
42 |
43 | | Assembly |
44 | Tests() |
45 | Run() |
46 | Skipped() |
47 | Ignored() |
48 | Failures() |
49 |
50 |
51 | | nunit.framework.tests.dll |
52 | 397 |
53 | |
54 | |
55 | 0 |
56 | 0 |
57 |
58 |
59 | | nunit.core.tests.dll |
60 | 355 |
61 | |
62 | |
63 | 0 |
64 | 0 |
65 |
66 |
67 | | nunit.util.tests.dll |
68 | 238 |
69 | |
70 | |
71 | 0 |
72 | 0 |
73 |
74 |
75 | | nunit.mocks.tests.dll |
76 | 43 |
77 | |
78 | |
79 | 0 |
80 | 0 |
81 |
82 |
83 | | nunit.extensions.tests.dll |
84 | 5 |
85 | |
86 | |
87 | 0 |
88 | 0 |
89 |
90 |
91 | | nunit-console.tests.dll |
92 | 40 |
93 | |
94 | |
95 | 0 |
96 | 0 |
97 |
98 |
99 | | nunit.uikit.tests.dll |
100 | 34 |
101 | |
102 | |
103 | 0 |
104 | 0 |
105 |
106 |
107 | | nunit-gui.tests.dll |
108 | 15 |
109 | |
110 | |
111 | 0 |
112 | 0 |
113 |
114 |
115 | | nunit.fixtures.tests.dll |
116 | 6 |
117 | |
118 | |
119 | 0 |
120 | 0 |
121 |
122 |
123 | Code Snippet Tests
124 |
125 | These tests create a test assembly from a snippet of code and then load and run
126 | the tests that it contains, verifying that the structure of the loaded tests is
127 | as expected and that the number of tests run, skipped, ignored or failed is
128 | correct.
129 |
130 |
131 |
132 | | NUnit.Fixtures.SnippetRunner |
133 |
134 |
135 | | Code |
136 | Tree() |
137 | Run() |
138 | Skipped() |
139 | Ignored() |
140 | Failures() |
141 |
142 |
143 | public class TestClass
144 | {
145 | }
146 | |
147 | EMPTY |
148 | 0 |
149 | 0 |
150 | 0 |
151 | 0 |
152 |
153 |
154 | using NUnit.Framework;
155 |
156 | [TestFixture]
157 | public class TestClass
158 | {
159 | }
160 | |
161 | TestClass |
162 | 0 |
163 | 0 |
164 | 0 |
165 | 0 |
166 |
167 |
168 | using NUnit.Framework;
169 |
170 | [TestFixture]
171 | public class TestClass
172 | {
173 | [Test]
174 | public void T1() { }
175 | [Test]
176 | public void T2() { }
177 | [Test]
178 | public void T3() { }
179 | }
180 | |
181 | TestClass
182 | >T1
183 | >T2
184 | >T3
185 | |
186 | 3 |
187 | 0 |
188 | 0 |
189 | 0 |
190 |
191 |
192 | using NUnit.Framework;
193 |
194 | [TestFixture]
195 | public class TestClass1
196 | {
197 | [Test]
198 | public void T1() { }
199 | }
200 |
201 | [TestFixture]
202 | public class TestClass2
203 | {
204 | [Test]
205 | public void T2() { }
206 | [Test]
207 | public void T3() { }
208 | }
209 | |
210 | TestClass1
211 | >T1
212 | TestClass2
213 | >T2
214 | >T3
215 | |
216 | 3 |
217 | 0 |
218 | 0 |
219 | 0 |
220 |
221 |
222 | using NUnit.Framework;
223 |
224 | [TestFixture]
225 | public class TestClass
226 | {
227 | [Test]
228 | public void T1() { }
229 | [Test, Ignore]
230 | public void T2() { }
231 | [Test]
232 | public void T3() { }
233 | }
234 | |
235 | TestClass
236 | >T1
237 | >T2
238 | >T3
239 | |
240 | 2 |
241 | 0 |
242 | 1 |
243 | 0 |
244 |
245 |
246 | using NUnit.Framework;
247 |
248 | [TestFixture]
249 | public class TestClass
250 | {
251 | [Test]
252 | public void T1() { }
253 | [Test, Explicit]
254 | public void T2() { }
255 | [Test]
256 | public void T3() { }
257 | }
258 | |
259 | TestClass
260 | >T1
261 | >T2
262 | >T3
263 | |
264 | 2 |
265 | 1 |
266 | 0 |
267 | 0 |
268 |
269 |
270 | Summary Information
271 |
272 |
273 | | fit.Summary |
274 |
275 |
276 |
277 |
278 |
--------------------------------------------------------------------------------
/packages/NUnit.2.5.9.10348/Tools/NUnitFitTests.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | NUnit Acceptance Tests
5 |
6 | Developers love self-referential programs! Hence, NUnit has always run all it's
7 | own tests, even those that are not really unit tests.
8 |
Now, beginning with NUnit 2.4, NUnit has top-level tests using Ward Cunningham's
9 | FIT framework. At this time, the tests are pretty rudimentary, but it's a start
10 | and it's a framework for doing more.
11 |
Running the Tests
12 | Open a console or shell window and navigate to the NUnit bin directory, which
13 | contains this file. To run the test under Microsoft .Net, enter the command
14 |
runFile NUnitFitTests.html TestResults.html .
15 | To run it under Mono, enter
16 | mono runFile.exe NUnitFitTests.html TestResults.html .
17 | Note the space and dot at the end of each command. The results of your test
18 | will be in TestResults.html in the same directory.
19 | Platform and CLR Version
20 |
21 |
22 | | NUnit.Fixtures.PlatformInfo |
23 |
24 |
25 | Verify Unit Tests
26 |
27 | Load and run the NUnit unit tests, verifying that the results are as expected.
28 | When these tests are run on different platforms, different numbers of tests may
29 | be skipped, so the values for Skipped and Run tests are informational only.
30 |
31 | The number of tests in each assembly should be constant across all platforms -
32 | any discrepancy usually means that one of the test source files was not
33 | compiled on the platform. There should be no failures and no tests ignored.
34 |
Note:
35 | At the moment, the nunit.extensions.tests assembly is failing because the
36 | fixture doesn't initialize addins in the test domain.
37 |
38 |
39 |
40 | | NUnit.Fixtures.AssemblyRunner |
41 |
42 |
43 | | Assembly |
44 | Tests() |
45 | Run() |
46 | Skipped() |
47 | Ignored() |
48 | Failures() |
49 |
50 |
51 | | nunit.framework.tests.dll |
52 | 397 |
53 | |
54 | |
55 | 0 |
56 | 0 |
57 |
58 |
59 | | nunit.core.tests.dll |
60 | 355 |
61 | |
62 | |
63 | 0 |
64 | 0 |
65 |
66 |
67 | | nunit.util.tests.dll |
68 | 238 |
69 | |
70 | |
71 | 0 |
72 | 0 |
73 |
74 |
75 | | nunit.mocks.tests.dll |
76 | 43 |
77 | |
78 | |
79 | 0 |
80 | 0 |
81 |
82 |
83 | | nunit.extensions.tests.dll |
84 | 5 |
85 | |
86 | |
87 | 0 |
88 | 0 |
89 |
90 |
91 | | nunit-console.tests.dll |
92 | 40 |
93 | |
94 | |
95 | 0 |
96 | 0 |
97 |
98 |
99 | | nunit.uikit.tests.dll |
100 | 34 |
101 | |
102 | |
103 | 0 |
104 | 0 |
105 |
106 |
107 | | nunit-gui.tests.dll |
108 | 15 |
109 | |
110 | |
111 | 0 |
112 | 0 |
113 |
114 |
115 | | nunit.fixtures.tests.dll |
116 | 6 |
117 | |
118 | |
119 | 0 |
120 | 0 |
121 |
122 |
123 | Code Snippet Tests
124 |
125 | These tests create a test assembly from a snippet of code and then load and run
126 | the tests that it contains, verifying that the structure of the loaded tests is
127 | as expected and that the number of tests run, skipped, ignored or failed is
128 | correct.
129 |
130 |
131 |
132 | | NUnit.Fixtures.SnippetRunner |
133 |
134 |
135 | | Code |
136 | Tree() |
137 | Run() |
138 | Skipped() |
139 | Ignored() |
140 | Failures() |
141 |
142 |
143 | public class TestClass
144 | {
145 | }
146 | |
147 | EMPTY |
148 | 0 |
149 | 0 |
150 | 0 |
151 | 0 |
152 |
153 |
154 | using NUnit.Framework;
155 |
156 | [TestFixture]
157 | public class TestClass
158 | {
159 | }
160 | |
161 | TestClass |
162 | 0 |
163 | 0 |
164 | 0 |
165 | 0 |
166 |
167 |
168 | using NUnit.Framework;
169 |
170 | [TestFixture]
171 | public class TestClass
172 | {
173 | [Test]
174 | public void T1() { }
175 | [Test]
176 | public void T2() { }
177 | [Test]
178 | public void T3() { }
179 | }
180 | |
181 | TestClass
182 | >T1
183 | >T2
184 | >T3
185 | |
186 | 3 |
187 | 0 |
188 | 0 |
189 | 0 |
190 |
191 |
192 | using NUnit.Framework;
193 |
194 | [TestFixture]
195 | public class TestClass1
196 | {
197 | [Test]
198 | public void T1() { }
199 | }
200 |
201 | [TestFixture]
202 | public class TestClass2
203 | {
204 | [Test]
205 | public void T2() { }
206 | [Test]
207 | public void T3() { }
208 | }
209 | |
210 | TestClass1
211 | >T1
212 | TestClass2
213 | >T2
214 | >T3
215 | |
216 | 3 |
217 | 0 |
218 | 0 |
219 | 0 |
220 |
221 |
222 | using NUnit.Framework;
223 |
224 | [TestFixture]
225 | public class TestClass
226 | {
227 | [Test]
228 | public void T1() { }
229 | [Test, Ignore]
230 | public void T2() { }
231 | [Test]
232 | public void T3() { }
233 | }
234 | |
235 | TestClass
236 | >T1
237 | >T2
238 | >T3
239 | |
240 | 2 |
241 | 0 |
242 | 1 |
243 | 0 |
244 |
245 |
246 | using NUnit.Framework;
247 |
248 | [TestFixture]
249 | public class TestClass
250 | {
251 | [Test]
252 | public void T1() { }
253 | [Test, Explicit]
254 | public void T2() { }
255 | [Test]
256 | public void T3() { }
257 | }
258 | |
259 | TestClass
260 | >T1
261 | >T2
262 | >T3
263 | |
264 | 2 |
265 | 1 |
266 | 0 |
267 | 0 |
268 |
269 |
270 | Summary Information
271 |
272 |
273 | | fit.Summary |
274 |
275 |
276 |
277 |
278 |
--------------------------------------------------------------------------------
/CoffeeScript.Compiler/Parser/CoffeescriptGrammar.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 | using System.Text;
5 | using Irony.Parsing;
6 | using Irony.Ast;
7 |
8 | namespace CoffeeScript.Compiler.Parser
9 | {
10 |
11 |
12 |
13 |
14 | [Language("coffeescript", "1.0.1", "Coffeescript grammar")]
15 | public class CoffeescriptGrammar : Grammar
16 | {
17 |
18 | void CreateBlock(ParsingContext ctx, ParseTreeNode node)
19 | {
20 | int i = 0;
21 | }
22 |
23 |
24 | public CoffeescriptGrammar() : base(false) //case-sensitive
25 | {
26 |
27 | // ReSharper disable InconsistentNaming
28 |
29 | //Terminals
30 | var NUMBER = new NumberLiteral("Number");
31 | var IDENTIFIER = new IdentifierTerminal("Identifier");
32 | var STATEMENT = ToTerm("break") | "continue" | "debugger";
33 | var STRING = new StringLiteral("String", "\"", StringOptions.AllowsAllEscapes);
34 |
35 | var comment = new CommentTerminal("comment", "#", "\n", "\r");
36 |
37 | NonGrammarTerminals.Add(comment);
38 |
39 | var BOOL = ToTerm("true") | "false" | "null" | "undefined";
40 | var CLASS = ToTerm("class");
41 | var EXTENDS = ToTerm("extends");
42 | var PARAM_START = ToTerm("(") | Empty;
43 | var PARAM_END = ToTerm(")") | Empty;
44 | var FUNC_GLYPH = ToTerm("=>") | ToTerm("->");
45 | var COMMA = ToTerm(",");
46 | var OPT_COMMA = ToTerm(",") | Empty;
47 | var INDEX_START = ToTerm("[");
48 | var INDEX_END = ToTerm("]");
49 | var INDEX_SOAK = ToTerm("?");
50 | var INDEX_PROTO = ToTerm("::");
51 | var SUPER = ToTerm("super");
52 | var FUNC_EXIST = ToTerm("?");
53 | var CALL_START = ToTerm("(");
54 | var CALL_END = ToTerm(")");
55 | var THIS = ToTerm("this");
56 | var TRY = ToTerm("try");
57 | var FINALLY = ToTerm("finally");
58 | var CATCH = ToTerm("catch");
59 | var THROW = ToTerm("throw");
60 | var WHILE = ToTerm("while");
61 | var WHEN = ToTerm("when");
62 | var UNTIL = ToTerm("until");
63 | var LOOP = ToTerm("loop");
64 | var FOR = ToTerm("for");
65 | var OWN = ToTerm("own");
66 | var FORIN = ToTerm("in");
67 | var FOROF = ToTerm("of");
68 | var BY = ToTerm("by");
69 | var SWITCH = ToTerm("switch");
70 | var ELSE = ToTerm("else");
71 | var LEADING_WHEN = ToTerm("When");
72 | var IF = ToTerm("IF");
73 | var POST_IF = ToTerm("if");
74 |
75 | #region Non Terminals
76 | var Body = new NonTerminal("Body", CreateBlock);
77 | var UnaryOp = new NonTerminal("UnaryOp");
78 | var Statement = new NonTerminal("Statement");
79 | var Expression = new NonTerminal("Expression");
80 | var Line = new NonTerminal("Line");
81 | var Return = new NonTerminal("Return");
82 | var Throw = new NonTerminal("Throw");
83 | var Comment = new NonTerminal("Comment");
84 | var Value = new NonTerminal("Value");
85 | var Invocation = new NonTerminal("Invocation");
86 | var Code = new NonTerminal("Code");
87 | var Operation = new NonTerminal("Operation");
88 | var Assign = new NonTerminal("Assign",typeof(AssignmentNode));
89 | var If = new NonTerminal("If");
90 | var Try = new NonTerminal("Try");
91 | var While = new NonTerminal("While");
92 | var For = new NonTerminal("For");
93 | var Switch = new NonTerminal("Switch");
94 | var Class = new NonTerminal("Class");
95 | var Block = new NonTerminal("Block",CreateBlock);
96 | var AlphaNumeric = new NonTerminal("AlphaNumeric");
97 | var Literal = new NonTerminal("Literal");
98 | var Assignable = new NonTerminal("Assignable");
99 | var AssignObj = new NonTerminal("AssignObj");
100 | var ObjAssignable = new NonTerminal("ObjAssignable");
101 | var ThisProperty = new NonTerminal("ThisProperty");
102 | var ParamList = new NonTerminal("ParamList");
103 | var Param = new NonTerminal("Param");
104 | var ParamVar = new NonTerminal("ParamVar");
105 | var ArrayNonTerm = new NonTerminal("Array");
106 | var ObjectNonTerm = new NonTerminal("Object");
107 | var Splat = new NonTerminal("Splat");
108 | var SimpleAssignable = new NonTerminal("SimpleAssignable");
109 | var Accessor = new NonTerminal("Accessor");
110 | var Parenthetical = new NonTerminal("Parenthetical");
111 | var This = new NonTerminal("This");
112 | var Range = new NonTerminal("Range");
113 | var Index = new NonTerminal("Index");
114 | var Slice = new NonTerminal("Slice");
115 | var AssignList = new NonTerminal("AssignList");
116 | var OptFuncExist = new NonTerminal("OptFuncExist");
117 | var Arguments = new NonTerminal("Arguments");
118 | var ArgList = new NonTerminal("ArgList");
119 | var RangeDots = new NonTerminal("RangeDots");
120 | var Arg = new NonTerminal("Arg");
121 | var SimpleArgs = new NonTerminal("SimpleArgs");
122 | var Catch = new NonTerminal("Catch");
123 | var WhileSource = new NonTerminal("WhileSource");
124 | var Loop = new NonTerminal("Loop");
125 | var ForBody = new NonTerminal("ForBody");
126 | var ForStart = new NonTerminal("ForStart");
127 | var ForSource = new NonTerminal("ForSource");
128 | var ForVariables = new NonTerminal("ForVariables");
129 | var ForValue = new NonTerminal("ForValue");
130 | var Whens = new NonTerminal("Whens");
131 | var When = new NonTerminal("When");
132 | var IfBlock = new NonTerminal("IfBlock");
133 | var BinaryOp = new NonTerminal("BinaryOp");
134 | var BinExpr = new NonTerminal("BinExpr",typeof(BinaryOperationNode));
135 | var CompoundAssignOp = new NonTerminal("CompoundAssign");
136 |
137 |
138 | #endregion
139 |
140 |
141 | #region Production rules
142 |
143 | BinaryOp.Rule = ToTerm("+") | "-" | "*";
144 |
145 | Body.Rule = MakePlusRule(Body, Line);
146 | Line.Rule = Expression + Eos | Statement + Eos;
147 |
148 | Statement.Rule = STATEMENT;
149 |
150 | Expression.Rule = Value | BinExpr | Assign;
151 |
152 | BinExpr.Rule = Value + BinaryOp + Value;
153 |
154 | Assign.Rule = (Assignable + "=" + Expression)
155 | | (Assignable + "=" + Indent + Expression + Dedent);
156 |
157 | SimpleAssignable.Rule = IDENTIFIER;
158 |
159 | Assignable.Rule = SimpleAssignable;
160 |
161 | Value.Rule = Assignable | Literal;
162 |
163 | AlphaNumeric.Rule = NUMBER | STRING;
164 | Literal.Rule = AlphaNumeric;
165 |
166 | #endregion
167 |
168 |
169 | MarkTransient(Line);
170 |
171 | Root = Body;
172 |
173 | LanguageFlags = LanguageFlags.CreateAst;
174 |
175 |
176 |
177 | // ReSharper enable InconsistentNaming
178 | }
179 |
180 | //Make parser indentation-aware
181 | public override void CreateTokenFilters(LanguageData language, TokenFilterList filters)
182 | {
183 | var options = OutlineOptions.ProduceIndents | OutlineOptions.CheckBraces | OutlineOptions.CheckOperator;
184 | var outlineFilter = new CodeOutlineFilter(language.GrammarData,options,null);
185 | filters.Add(outlineFilter);
186 | }
187 |
188 | }
189 | }
190 |
--------------------------------------------------------------------------------
/CoffeeScript.Compiler/Parser/CoffeescriptGrammar2.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using Irony.Parsing;
3 |
4 | namespace CoffeeScript.Compiler.Parser
5 | {
6 | public class CoffeescriptGrammar2 : Grammar
7 | {
8 | public CoffeescriptGrammar2() : base(false) //case-sensitive
9 | {
10 |
11 |
12 | // ReSharper disable InconsistentNaming
13 |
14 | //Terminals
15 | var NUMBER = new NumberLiteral("Number");
16 | var IDENTIFIER = new IdentifierTerminal("Identifier");
17 | var STATEMENT = ToTerm("break") | "continue" | "debugger";
18 | var STRING = new StringLiteral("String", "\"", StringOptions.AllowsAllEscapes);
19 | // actually this could be simplified to @"^`[^`]*`" but we're sticking to the original here
20 | //var JS = new RegexBasedTerminal("JS", @"^`[^`]*(?:\.[^`]*)*`");
21 | var JS = new QuotedValueLiteral("JS", "`", TypeCode.String);
22 | var HERECOMMENT = new QuotedValueLiteral("HERECOMMENT", "###", TypeCode.String);
23 | var comment = new CommentTerminal("comment", "#", "\n", "\r");
24 |
25 | NonGrammarTerminals.Add(comment);
26 | //FIXME!
27 | /*
28 | var REGEX = new RegexBasedTerminal("REGEX",
29 | @"
30 | / ^
31 | / (?! \s ) # disallow leading whitespace
32 | [^ [ / \n \\ ]* # every other thing
33 | (?:
34 | (?: \[\s\S] # anything escaped
35 | | \[ # character class
36 | [^ \] \n \\ ]*
37 | (?: \\[\s\S] [^ \] \n \\ ]* )*
38 | ]
39 | ) [^ [ / \n \\ ]*
40 | )*
41 | / [imgy]{0,4} (?!\w)
42 | /
43 | ");
44 | */
45 |
46 | var BOOL = ToTerm("true") | "false" | "null" | "undefined";
47 | var CLASS = ToTerm("class");
48 | var EXTENDS = ToTerm("extends");
49 | var PARAM_START = ToTerm("(") | Empty;
50 | var PARAM_END = ToTerm(")") | Empty;
51 | var FUNC_GLYPH = ToTerm("=>") | ToTerm("->");
52 | var COMMA = ToTerm(",");
53 | var OPT_COMMA = ToTerm(",") | Empty;
54 | //
55 | var INDEX_START = ToTerm("[");
56 | var INDEX_END = ToTerm("]");
57 | var INDEX_SOAK = ToTerm("?");
58 | var INDEX_PROTO = ToTerm("::");
59 | var SUPER = ToTerm("super");
60 | var FUNC_EXIST = ToTerm("?");
61 | var CALL_START = ToTerm("(");
62 | var CALL_END = ToTerm(")");
63 | var THIS = ToTerm("this");
64 | var TRY = ToTerm("try");
65 | var FINALLY = ToTerm("finally");
66 | var CATCH = ToTerm("catch");
67 | var THROW = ToTerm("throw");
68 | var WHILE = ToTerm("while");
69 | var WHEN = ToTerm("when");
70 | var UNTIL = ToTerm("until");
71 | var LOOP = ToTerm("loop");
72 | var FOR = ToTerm("for");
73 | var OWN = ToTerm("own");
74 | var FORIN = ToTerm("in");
75 | var FOROF = ToTerm("of");
76 | var BY = ToTerm("by");
77 | var SWITCH = ToTerm("switch");
78 | var ELSE = ToTerm("else");
79 | var LEADING_WHEN = ToTerm("When");
80 | var IF = ToTerm("IF");
81 | var POST_IF = ToTerm("if");
82 |
83 | //TERMINATOR terminal is Eol non-terminal here
84 |
85 | //Non terminals
86 | var Body = new NonTerminal("Body");
87 | var Eol = new NonTerminal("Eol");
88 | var UnaryOp = new NonTerminal("UnaryOp");
89 | var Statement = new NonTerminal("Statement");
90 | var Expression = new NonTerminal("Expression");
91 | var Line = new NonTerminal("Line");
92 | var Return = new NonTerminal("Return");
93 | var Throw = new NonTerminal("Throw");
94 | var Comment = new NonTerminal("Comment");
95 | var Value = new NonTerminal("Value");
96 | var Invocation = new NonTerminal("Invocation");
97 | var Code = new NonTerminal("Code");
98 | var Operation = new NonTerminal("Operation");
99 | var Assign = new NonTerminal("Assign");
100 | var If = new NonTerminal("If");
101 | var Try = new NonTerminal("Try");
102 | var While = new NonTerminal("While");
103 | var For = new NonTerminal("For");
104 | var Switch = new NonTerminal("Switch");
105 | var Class = new NonTerminal("Class");
106 | var Block = new NonTerminal("Block");
107 | var AlphaNumeric = new NonTerminal("AlphaNumeric");
108 | var Literal = new NonTerminal("Literal");
109 | var Assignable = new NonTerminal("Assignable");
110 | var AssignObj = new NonTerminal("AssignObj");
111 | var ObjAssignable = new NonTerminal("ObjAssignable");
112 | var ThisProperty = new NonTerminal("ThisProperty");
113 | var ParamList = new NonTerminal("ParamList");
114 | var Param = new NonTerminal("Param");
115 | var ParamVar = new NonTerminal("ParamVar");
116 | var ArrayNonTerm = new NonTerminal("Array");
117 | var ObjectNonTerm = new NonTerminal("Object");
118 | var Splat = new NonTerminal("Splat");
119 | var SimpleAssignable = new NonTerminal("SimpleAssignable");
120 | var Accessor = new NonTerminal("Accessor");
121 | var Parenthetical = new NonTerminal("Parenthetical");
122 | var This = new NonTerminal("This");
123 | var Range = new NonTerminal("Range");
124 | var Index = new NonTerminal("Index");
125 | var Slice = new NonTerminal("Slice");
126 | var AssignList = new NonTerminal("AssignList");
127 | var OptFuncExist = new NonTerminal("OptFuncExist");
128 | var Arguments = new NonTerminal("Arguments");
129 | var ArgList = new NonTerminal("ArgList");
130 | var RangeDots = new NonTerminal("RangeDots");
131 | var Arg = new NonTerminal("Arg");
132 | var SimpleArgs = new NonTerminal("SimpleArgs");
133 | var Catch = new NonTerminal("Catch");
134 | var WhileSource = new NonTerminal("WhileSource");
135 | var Loop = new NonTerminal("Loop");
136 | var ForBody = new NonTerminal("ForBody");
137 | var ForStart = new NonTerminal("ForStart");
138 | var ForSource = new NonTerminal("ForSource");
139 | var ForVariables = new NonTerminal("ForVariables");
140 | var ForValue = new NonTerminal("ForValue");
141 | var Whens = new NonTerminal("Whens");
142 | var When = new NonTerminal("When");
143 | var IfBlock = new NonTerminal("IfBlock");
144 | var BinaryOp = new NonTerminal("BinaryOp");
145 | var CompoundAssignOp = new NonTerminal("CompoundAssign");
146 |
147 | // ReSharper restore InconsistentNaming
148 |
149 | UnaryOp.Rule = ToTerm("+") | ToTerm("-");
150 |
151 | CompoundAssignOp.Rule = ToTerm("+=") | "-=" | "*=" | "/=";
152 |
153 | Eol.Rule = NewLine | ";";
154 |
155 | Statement.Rule = Return | Throw | Comment | STATEMENT;
156 | Expression.Rule = Value | Invocation | Code | Operation | Assign
157 | | If | Try | While | For | Switch | Class;
158 |
159 | Block.Rule = Indent + Body + Dedent;
160 | AlphaNumeric.Rule = NUMBER | STRING;
161 | Literal.Rule = AlphaNumeric | JS | BOOL; // | REGEX; FIXME
162 |
163 | AssignObj.Rule = ObjAssignable | (ObjAssignable + ":" + Expression)
164 | | (ObjAssignable + ":" + Indent + Expression + Dedent);
165 |
166 | ObjAssignable.Rule = IDENTIFIER | AlphaNumeric | ThisProperty;
167 |
168 | Return.Rule = "return" + Expression | "return";
169 |
170 | Comment.Rule = HERECOMMENT;
171 |
172 | Code.Rule = (PARAM_START + ParamList + PARAM_END + FUNC_GLYPH + Block)
173 | | (FUNC_GLYPH + Block);
174 |
175 | ParamList.Rule = MakePlusRule(ParamList, COMMA, Param);
176 |
177 | Param.Rule = ParamVar
178 | | (ParamVar + "...")
179 | | (ParamVar + "=" + Expression);
180 |
181 | ParamVar.Rule = IDENTIFIER | ThisProperty | ArrayNonTerm | ObjectNonTerm;
182 |
183 | Splat.Rule = Expression + "...";
184 |
185 | SimpleAssignable.Rule = IDENTIFIER | Value + Accessor | Invocation + Accessor | ThisProperty;
186 |
187 | Assignable.Rule = SimpleAssignable | ArrayNonTerm | ObjectNonTerm;
188 |
189 | Value.Rule = Assignable | Literal | Parenthetical | Range | This;
190 |
191 | Accessor.Rule = ToTerm(".") + IDENTIFIER
192 | | ToTerm("?:") + IDENTIFIER
193 | | ToTerm("::") + IDENTIFIER
194 | | ToTerm("::")
195 | | Index
196 | | Slice;
197 |
198 | Index.Rule = INDEX_START + Expression + INDEX_END
199 | | INDEX_SOAK + Index
200 | | INDEX_PROTO + Index;
201 |
202 | ObjectNonTerm.Rule = "{" + AssignList + OPT_COMMA + "}";
203 |
204 | AssignList.Rule = Empty
205 | | AssignObj
206 | | AssignList + COMMA + AssignObj
207 | | AssignList + OPT_COMMA + Eol + AssignObj
208 | | AssignList + OPT_COMMA + Indent + AssignList + OPT_COMMA + Dedent;
209 |
210 | Class.Rule = CLASS
211 | | CLASS + Block
212 | | CLASS + EXTENDS + Value
213 | | CLASS + EXTENDS + Value + Block
214 | | CLASS + SimpleAssignable
215 | | CLASS + SimpleAssignable + Block
216 | | CLASS + SimpleAssignable + EXTENDS + Value
217 | | CLASS + SimpleAssignable + EXTENDS + Value + Block;
218 |
219 |
220 | Invocation.Rule = Value + OptFuncExist + Arguments
221 | | Invocation + OptFuncExist + Arguments
222 | | SUPER
223 | | SUPER + Arguments;
224 |
225 |
226 | OptFuncExist.Rule = Empty | FUNC_EXIST;
227 |
228 | Arguments.Rule = CALL_START + CALL_END
229 | | CALL_START + ArgList + OPT_COMMA + CALL_END;
230 |
231 | This.Rule = THIS | "@";
232 |
233 | ThisProperty.Rule = "@" + IDENTIFIER;
234 |
235 | ArrayNonTerm.Rule = ToTerm("[") + "]"
236 | | "[" + ArgList + OPT_COMMA + "]";
237 |
238 | RangeDots.Rule = ToTerm("..") | "...";
239 |
240 | Range.Rule = "[" + Expression + RangeDots + Expression + "]";
241 |
242 | Slice.Rule = INDEX_START + Expression + RangeDots + Expression + INDEX_END
243 | | INDEX_START + Expression + RangeDots + INDEX_END
244 | | INDEX_START + RangeDots + Expression + INDEX_END;
245 |
246 |
247 |
248 |
249 | //FIXME:
250 | ArgList.Rule = MakePlusRule(ArgList, COMMA, Arg, TermListOptions.AllowTrailingDelimiter);
251 |
252 |
253 | // ArgList: [
254 | // o 'Arg', -> [$1]
255 | // o 'ArgList , Arg', -> $1.concat $3
256 | // o 'ArgList OptComma TERMINATOR Arg', -> $1.concat $4
257 | // o 'INDENT ArgList OptComma OUTDENT', -> $2
258 | // o 'ArgList OptComma INDENT ArgList OptComma OUTDENT', -> $1.concat $4
259 | //]
260 |
261 | Arg.Rule = Expression | Splat;
262 |
263 | SimpleArgs.Rule = Expression | SimpleArgs + COMMA + Expression;
264 |
265 | Try.Rule = TRY + Block
266 | | TRY + Block + Catch
267 | | TRY + Block + FINALLY + Block
268 | | TRY + Block + Catch + FINALLY + Block;
269 |
270 | Catch.Rule = CATCH + IDENTIFIER + Block;
271 |
272 | Throw.Rule = THROW + Expression;
273 |
274 | Parenthetical.Rule = "(" + Body + ")"
275 | | "(" + Indent + Body + Dedent + ")";
276 |
277 | WhileSource.Rule = WHILE + Expression
278 | | WHILE + Expression + WHEN + Expression
279 | | UNTIL + Expression
280 | | UNTIL + Expression + WHEN + Expression;
281 |
282 | While.Rule = WhileSource + Block
283 | | Statement + WhileSource
284 | | Expression + WhileSource
285 | | Loop;
286 |
287 | Loop.Rule = LOOP + Block
288 | | LOOP + Expression;
289 |
290 | For.Rule = Statement + ForBody
291 | | Expression + ForBody
292 | | ForBody + Block;
293 |
294 | ForBody.Rule = FOR + Range
295 | | ForStart + ForSource;
296 |
297 | ForStart.Rule = FOR + ForVariables
298 | | FOR + OWN + ForVariables;
299 |
300 | ForValue.Rule = IDENTIFIER | ArrayNonTerm | ObjectNonTerm;
301 |
302 | ForVariables.Rule = ForValue
303 | | ForValue + COMMA + ForValue;
304 |
305 | ForSource.Rule = FORIN + Expression
306 | | FOROF + Expression
307 | | FORIN + Expression + WHEN + Expression
308 | | FOROF + Expression + WHEN + Expression
309 | | FORIN + Expression + BY + Expression;
310 |
311 | Switch.Rule = SWITCH + Expression + Indent + Whens + Dedent
312 | | SWITCH + Expression + Indent + Whens + ELSE + Block + Dedent
313 | | SWITCH + Indent + Whens + Dedent
314 | | SWITCH + Indent + Whens + ELSE + Block + Dedent;
315 |
316 | Whens.Rule = When
317 | | Whens + When;
318 |
319 |
320 | When.Rule = LEADING_WHEN + SimpleArgs + Block
321 | | LEADING_WHEN + SimpleArgs + Block + Eol;
322 |
323 | IfBlock.Rule = IF + Expression + Block
324 | | IfBlock + ELSE + IF + Expression + Block;
325 |
326 | If.Rule = IfBlock
327 | | IfBlock + ELSE + Block
328 | | Statement + POST_IF + Expression
329 | | Expression + POST_IF + Expression;
330 |
331 | //FIXME: operations (lacks assignment and compound assignement)
332 | Operation.Rule = UnaryOp + Expression
333 | | Expression + "?"
334 | | Expression + BinaryOp + Expression;
335 |
336 |
337 |
338 |
339 | Root = Body;
340 | }
341 | }
342 | }
343 |
--------------------------------------------------------------------------------
/packages/NUnit.2.5.9.10348/fit-license.txt:
--------------------------------------------------------------------------------
1 |
2 |
3 | GNU GENERAL PUBLIC LICENSE
4 | Version 2, June 1991
5 |
6 | Copyright (C) 1989, 1991 Free Software Foundation, Inc.
7 | 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
8 | Everyone is permitted to copy and distribute verbatim copies
9 | of this license document, but changing it is not allowed.
10 |
11 | Preamble
12 |
13 | The licenses for most software are designed to take away your
14 | freedom to share and change it. By contrast, the GNU General Public
15 | License is intended to guarantee your freedom to share and change free
16 | software--to make sure the software is free for all its users. This
17 | General Public License applies to most of the Free Software
18 | Foundation's software and to any other program whose authors commit to
19 | using it. (Some other Free Software Foundation software is covered by
20 | the GNU Library General Public License instead.) You can apply it to
21 | your programs, too.
22 |
23 | When we speak of free software, we are referring to freedom, not
24 | price. Our General Public Licenses are designed to make sure that you
25 | have the freedom to distribute copies of free software (and charge for
26 | this service if you wish), that you receive source code or can get it
27 | if you want it, that you can change the software or use pieces of it
28 | in new free programs; and that you know you can do these things.
29 |
30 | To protect your rights, we need to make restrictions that forbid
31 | anyone to deny you these rights or to ask you to surrender the rights.
32 | These restrictions translate to certain responsibilities for you if you
33 | distribute copies of the software, or if you modify it.
34 |
35 | For example, if you distribute copies of such a program, whether
36 | gratis or for a fee, you must give the recipients all the rights that
37 | you have. You must make sure that they, too, receive or can get the
38 | source code. And you must show them these terms so they know their
39 | rights.
40 |
41 | We protect your rights with two steps: (1) copyright the software, and
42 | (2) offer you this license which gives you legal permission to copy,
43 | distribute and/or modify the software.
44 |
45 | Also, for each author's protection and ours, we want to make certain
46 | that everyone understands that there is no warranty for this free
47 | software. If the software is modified by someone else and passed on, we
48 | want its recipients to know that what they have is not the original, so
49 | that any problems introduced by others will not reflect on the original
50 | authors' reputations.
51 |
52 | Finally, any free program is threatened constantly by software
53 | patents. We wish to avoid the danger that redistributors of a free
54 | program will individually obtain patent licenses, in effect making the
55 | program proprietary. To prevent this, we have made it clear that any
56 | patent must be licensed for everyone's free use or not licensed at all.
57 |
58 | The precise terms and conditions for copying, distribution and
59 | modification follow.
60 |
61 | GNU GENERAL PUBLIC LICENSE
62 | TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
63 |
64 | 0. This License applies to any program or other work which contains
65 | a notice placed by the copyright holder saying it may be distributed
66 | under the terms of this General Public License. The "Program", below,
67 | refers to any such program or work, and a "work based on the Program"
68 | means either the Program or any derivative work under copyright law:
69 | that is to say, a work containing the Program or a portion of it,
70 | either verbatim or with modifications and/or translated into another
71 | language. (Hereinafter, translation is included without limitation in
72 | the term "modification".) Each licensee is addressed as "you".
73 |
74 | Activities other than copying, distribution and modification are not
75 | covered by this License; they are outside its scope. The act of
76 | running the Program is not restricted, and the output from the Program
77 | is covered only if its contents constitute a work based on the
78 | Program (independent of having been made by running the Program).
79 | Whether that is true depends on what the Program does.
80 |
81 | 1. You may copy and distribute verbatim copies of the Program's
82 | source code as you receive it, in any medium, provided that you
83 | conspicuously and appropriately publish on each copy an appropriate
84 | copyright notice and disclaimer of warranty; keep intact all the
85 | notices that refer to this License and to the absence of any warranty;
86 | and give any other recipients of the Program a copy of this License
87 | along with the Program.
88 |
89 | You may charge a fee for the physical act of transferring a copy, and
90 | you may at your option offer warranty protection in exchange for a fee.
91 |
92 | 2. You may modify your copy or copies of the Program or any portion
93 | of it, thus forming a work based on the Program, and copy and
94 | distribute such modifications or work under the terms of Section 1
95 | above, provided that you also meet all of these conditions:
96 |
97 | a) You must cause the modified files to carry prominent notices
98 | stating that you changed the files and the date of any change.
99 |
100 | b) You must cause any work that you distribute or publish, that in
101 | whole or in part contains or is derived from the Program or any
102 | part thereof, to be licensed as a whole at no charge to all third
103 | parties under the terms of this License.
104 |
105 | c) If the modified program normally reads commands interactively
106 | when run, you must cause it, when started running for such
107 | interactive use in the most ordinary way, to print or display an
108 | announcement including an appropriate copyright notice and a
109 | notice that there is no warranty (or else, saying that you provide
110 | a warranty) and that users may redistribute the program under
111 | these conditions, and telling the user how to view a copy of this
112 | License. (Exception: if the Program itself is interactive but
113 | does not normally print such an announcement, your work based on
114 | the Program is not required to print an announcement.)
115 |
116 | These requirements apply to the modified work as a whole. If
117 | identifiable sections of that work are not derived from the Program,
118 | and can be reasonably considered independent and separate works in
119 | themselves, then this License, and its terms, do not apply to those
120 | sections when you distribute them as separate works. But when you
121 | distribute the same sections as part of a whole which is a work based
122 | on the Program, the distribution of the whole must be on the terms of
123 | this License, whose permissions for other licensees extend to the
124 | entire whole, and thus to each and every part regardless of who wrote it.
125 |
126 | Thus, it is not the intent of this section to claim rights or contest
127 | your rights to work written entirely by you; rather, the intent is to
128 | exercise the right to control the distribution of derivative or
129 | collective works based on the Program.
130 |
131 | In addition, mere aggregation of another work not based on the Program
132 | with the Program (or with a work based on the Program) on a volume of
133 | a storage or distribution medium does not bring the other work under
134 | the scope of this License.
135 |
136 | 3. You may copy and distribute the Program (or a work based on it,
137 | under Section 2) in object code or executable form under the terms of
138 | Sections 1 and 2 above provided that you also do one of the following:
139 |
140 | a) Accompany it with the complete corresponding machine-readable
141 | source code, which must be distributed under the terms of Sections
142 | 1 and 2 above on a medium customarily used for software interchange; or,
143 |
144 | b) Accompany it with a written offer, valid for at least three
145 | years, to give any third party, for a charge no more than your
146 | cost of physically performing source distribution, a complete
147 | machine-readable copy of the corresponding source code, to be
148 | distributed under the terms of Sections 1 and 2 above on a medium
149 | customarily used for software interchange; or,
150 |
151 | c) Accompany it with the information you received as to the offer
152 | to distribute corresponding source code. (This alternative is
153 | allowed only for noncommercial distribution and only if you
154 | received the program in object code or executable form with such
155 | an offer, in accord with Subsection b above.)
156 |
157 | The source code for a work means the preferred form of the work for
158 | making modifications to it. For an executable work, complete source
159 | code means all the source code for all modules it contains, plus any
160 | associated interface definition files, plus the scripts used to
161 | control compilation and installation of the executable. However, as a
162 | special exception, the source code distributed need not include
163 | anything that is normally distributed (in either source or binary
164 | form) with the major components (compiler, kernel, and so on) of the
165 | operating system on which the executable runs, unless that component
166 | itself accompanies the executable.
167 |
168 | If distribution of executable or object code is made by offering
169 | access to copy from a designated place, then offering equivalent
170 | access to copy the source code from the same place counts as
171 | distribution of the source code, even though third parties are not
172 | compelled to copy the source along with the object code.
173 |
174 | 4. You may not copy, modify, sublicense, or distribute the Program
175 | except as expressly provided under this License. Any attempt
176 | otherwise to copy, modify, sublicense or distribute the Program is
177 | void, and will automatically terminate your rights under this License.
178 | However, parties who have received copies, or rights, from you under
179 | this License will not have their licenses terminated so long as such
180 | parties remain in full compliance.
181 |
182 | 5. You are not required to accept this License, since you have not
183 | signed it. However, nothing else grants you permission to modify or
184 | distribute the Program or its derivative works. These actions are
185 | prohibited by law if you do not accept this License. Therefore, by
186 | modifying or distributing the Program (or any work based on the
187 | Program), you indicate your acceptance of this License to do so, and
188 | all its terms and conditions for copying, distributing or modifying
189 | the Program or works based on it.
190 |
191 | 6. Each time you redistribute the Program (or any work based on the
192 | Program), the recipient automatically receives a license from the
193 | original licensor to copy, distribute or modify the Program subject to
194 | these terms and conditions. You may not impose any further
195 | restrictions on the recipients' exercise of the rights granted herein.
196 | You are not responsible for enforcing compliance by third parties to
197 | this License.
198 |
199 | 7. If, as a consequence of a court judgment or allegation of patent
200 | infringement or for any other reason (not limited to patent issues),
201 | conditions are imposed on you (whether by court order, agreement or
202 | otherwise) that contradict the conditions of this License, they do not
203 | excuse you from the conditions of this License. If you cannot
204 | distribute so as to satisfy simultaneously your obligations under this
205 | License and any other pertinent obligations, then as a consequence you
206 | may not distribute the Program at all. For example, if a patent
207 | license would not permit royalty-free redistribution of the Program by
208 | all those who receive copies directly or indirectly through you, then
209 | the only way you could satisfy both it and this License would be to
210 | refrain entirely from distribution of the Program.
211 |
212 | If any portion of this section is held invalid or unenforceable under
213 | any particular circumstance, the balance of the section is intended to
214 | apply and the section as a whole is intended to apply in other
215 | circumstances.
216 |
217 | It is not the purpose of this section to induce you to infringe any
218 | patents or other property right claims or to contest validity of any
219 | such claims; this section has the sole purpose of protecting the
220 | integrity of the free software distribution system, which is
221 | implemented by public license practices. Many people have made
222 | generous contributions to the wide range of software distributed
223 | through that system in reliance on consistent application of that
224 | system; it is up to the author/donor to decide if he or she is willing
225 | to distribute software through any other system and a licensee cannot
226 | impose that choice.
227 |
228 | This section is intended to make thoroughly clear what is believed to
229 | be a consequence of the rest of this License.
230 |
231 | 8. If the distribution and/or use of the Program is restricted in
232 | certain countries either by patents or by copyrighted interfaces, the
233 | original copyright holder who places the Program under this License
234 | may add an explicit geographical distribution limitation excluding
235 | those countries, so that distribution is permitted only in or among
236 | countries not thus excluded. In such case, this License incorporates
237 | the limitation as if written in the body of this License.
238 |
239 | 9. The Free Software Foundation may publish revised and/or new versions
240 | of the General Public License from time to time. Such new versions will
241 | be similar in spirit to the present version, but may differ in detail to
242 | address new problems or concerns.
243 |
244 | Each version is given a distinguishing version number. If the Program
245 | specifies a version number of this License which applies to it and "any
246 | later version", you have the option of following the terms and conditions
247 | either of that version or of any later version published by the Free
248 | Software Foundation. If the Program does not specify a version number of
249 | this License, you may choose any version ever published by the Free Software
250 | Foundation.
251 |
252 | 10. If you wish to incorporate parts of the Program into other free
253 | programs whose distribution conditions are different, write to the author
254 | to ask for permission. For software which is copyrighted by the Free
255 | Software Foundation, write to the Free Software Foundation; we sometimes
256 | make exceptions for this. Our decision will be guided by the two goals
257 | of preserving the free status of all derivatives of our free software and
258 | of promoting the sharing and reuse of software generally.
259 |
260 | NO WARRANTY
261 |
262 | 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
263 | FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
264 | OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
265 | PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
266 | OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
267 | MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
268 | TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
269 | PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
270 | REPAIR OR CORRECTION.
271 |
272 | 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
273 | WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
274 | REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
275 | INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
276 | OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
277 | TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
278 | YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
279 | PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
280 | POSSIBILITY OF SUCH DAMAGES.
281 |
282 | END OF TERMS AND CONDITIONS
283 |
284 | How to Apply These Terms to Your New Programs
285 |
286 | If you develop a new program, and you want it to be of the greatest
287 | possible use to the public, the best way to achieve this is to make it
288 | free software which everyone can redistribute and change under these terms.
289 |
290 | To do so, attach the following notices to the program. It is safest
291 | to attach them to the start of each source file to most effectively
292 | convey the exclusion of warranty; and each file should have at least
293 | the "copyright" line and a pointer to where the full notice is found.
294 |
295 |
296 | Copyright (C)
297 |
298 | This program is free software; you can redistribute it and/or modify
299 | it under the terms of the GNU General Public License as published by
300 | the Free Software Foundation; either version 2 of the License, or
301 | (at your option) any later version.
302 |
303 | This program is distributed in the hope that it will be useful,
304 | but WITHOUT ANY WARRANTY; without even the implied warranty of
305 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
306 | GNU General Public License for more details.
307 |
308 | You should have received a copy of the GNU General Public License
309 | along with this program; if not, write to the Free Software
310 | Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
311 |
312 |
313 | Also add information on how to contact you by electronic and paper mail.
314 |
315 | If the program is interactive, make it output a short notice like this
316 | when it starts in an interactive mode:
317 |
318 | Gnomovision version 69, Copyright (C) year name of author
319 | Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
320 | This is free software, and you are welcome to redistribute it
321 | under certain conditions; type `show c' for details.
322 |
323 | The hypothetical commands `show w' and `show c' should show the appropriate
324 | parts of the General Public License. Of course, the commands you use may
325 | be called something other than `show w' and `show c'; they could even be
326 | mouse-clicks or menu items--whatever suits your program.
327 |
328 | You should also get your employer (if you work as a programmer) or your
329 | school, if any, to sign a "copyright disclaimer" for the program, if
330 | necessary. Here is a sample; alter the names:
331 |
332 | Yoyodyne, Inc., hereby disclaims all copyright interest in the program
333 | `Gnomovision' (which makes passes at compilers) written by James Hacker.
334 |
335 | , 1 April 1989
336 | Ty Coon, President of Vice
337 |
338 | This General Public License does not permit incorporating your program into
339 | proprietary programs. If your program is a subroutine library, you may
340 | consider it more useful to permit linking proprietary applications with the
341 | library. If this is what you want to do, use the GNU Library General
342 | Public License instead of this License.
--------------------------------------------------------------------------------