Add specs for begin/end patterns with nested patterns.

2026-04-06 03:02:13 -04:00 · 2012-07-31 16:35:04 -07:00
parent 289b15d032
commit 6af22fce67
1 changed files with 58 additions and 34 deletions
--- a/spec/app/parser-spec.coffee
+++ b/spec/app/parser-spec.coffee
@@ -11,46 +11,70 @@ fdescribe "Parser", ->
    plist.parseString coffee_plist, (err, grammar) ->
      parser = new Parser(grammar[0])

-  describe ".getLineTokens(line, state)", ->
-    describe "when the state is omitted (start state)", ->
-      describe "when the entire line matches a single pattern with no capture groups", ->
-        it "returns a single token with the correct scope", ->
-          {tokens, state} = parser.getLineTokens("return")
+  describe ".getLineTokens(line, currentRule)", ->
+    describe "when the entire line matches a single pattern with no capture groups", ->
+      it "returns a single token with the correct scope", ->
+        {tokens, currentRule} = parser.getLineTokens("return")

-          expect(tokens.length).toBe 1
-          [token] = tokens
-          expect(token.scopes).toEqual ['source.coffee', 'keyword.control.coffee']
+        expect(tokens.length).toBe 1
+        [token] = tokens
+        expect(token.scopes).toEqual ['source.coffee', 'keyword.control.coffee']

-      describe "when the entire line matches a single pattern with capture groups", ->
-        it "returns a single token with the correct scope", ->
-          {tokens, state} = parser.getLineTokens("new foo.bar.Baz")
+    describe "when the entire line matches a single pattern with capture groups", ->
+      it "returns a single token with the correct scope", ->
+        {tokens, currentRule} = parser.getLineTokens("new foo.bar.Baz")

-          expect(tokens.length).toBe 3
-          [newOperator, whitespace, className] = tokens
-          expect(newOperator).toEqual value: 'new', scopes: ['source.coffee', 'meta.class.instance.constructor', 'keyword.operator.new.coffee']
-          expect(whitespace).toEqual value: ' ', scopes: ['source.coffee', 'meta.class.instance.constructor']
-          expect(className).toEqual value: 'foo.bar.Baz', scopes: ['source.coffee', 'meta.class.instance.constructor', 'entity.name.type.instance.coffee']
+        expect(tokens.length).toBe 3
+        [newOperator, whitespace, className] = tokens
+        expect(newOperator).toEqual value: 'new', scopes: ['source.coffee', 'meta.class.instance.constructor', 'keyword.operator.new.coffee']
+        expect(whitespace).toEqual value: ' ', scopes: ['source.coffee', 'meta.class.instance.constructor']
+        expect(className).toEqual value: 'foo.bar.Baz', scopes: ['source.coffee', 'meta.class.instance.constructor', 'entity.name.type.instance.coffee']

-      describe "when the line matches multiple patterns", ->
-        it "returns multiple tokens, filling in regions that don't match patterns with tokens in the grammar's global scope", ->
-          {tokens, state} = parser.getLineTokens(" return new foo.bar.Baz ")
+    describe "when the line matches multiple patterns", ->
+      it "returns multiple tokens, filling in regions that don't match patterns with tokens in the grammar's global scope", ->
+        {tokens, currentRule} = parser.getLineTokens(" return new foo.bar.Baz ")

-          expect(tokens.length).toBe 7
+        expect(tokens.length).toBe 7

-          expect(tokens[0]).toEqual value: ' ', scopes: ['source.coffee']
-          expect(tokens[1]).toEqual value: 'return', scopes: ['source.coffee', 'keyword.control.coffee']
-          expect(tokens[2]).toEqual value: ' ', scopes: ['source.coffee']
-          expect(tokens[3]).toEqual value: 'new', scopes: ['source.coffee', 'meta.class.instance.constructor', 'keyword.operator.new.coffee']
-          expect(tokens[4]).toEqual value: ' ', scopes: ['source.coffee', 'meta.class.instance.constructor']
-          expect(tokens[5]).toEqual value: 'foo.bar.Baz', scopes: ['source.coffee', 'meta.class.instance.constructor', 'entity.name.type.instance.coffee']
-          expect(tokens[6]).toEqual value: ' ', scopes: ['source.coffee']
+        expect(tokens[0]).toEqual value: ' ', scopes: ['source.coffee']
+        expect(tokens[1]).toEqual value: 'return', scopes: ['source.coffee', 'keyword.control.coffee']
+        expect(tokens[2]).toEqual value: ' ', scopes: ['source.coffee']
+        expect(tokens[3]).toEqual value: 'new', scopes: ['source.coffee', 'meta.class.instance.constructor', 'keyword.operator.new.coffee']
+        expect(tokens[4]).toEqual value: ' ', scopes: ['source.coffee', 'meta.class.instance.constructor']
+        expect(tokens[5]).toEqual value: 'foo.bar.Baz', scopes: ['source.coffee', 'meta.class.instance.constructor', 'entity.name.type.instance.coffee']
+        expect(tokens[6]).toEqual value: ' ', scopes: ['source.coffee']

-      describe "when the line matches a begin and end pattern", ->
-        it "returns tokens based on the beginCaptures, endCaptures and the child scope", ->
-          {tokens, state} = parser.getLineTokens("'''single-quoted heredoc'''")
+    describe "when the line matches a begin/end pattern", ->
+      it "returns tokens based on the beginCaptures, endCaptures and the child scope", ->
+        {tokens, currentRule} = parser.getLineTokens("'''single-quoted heredoc'''")

-          expect(tokens.length).toBe 3
+        expect(tokens.length).toBe 3

-          expect(tokens[0]).toEqual value: "'''", scopes: ['source.coffee', 'string.quoted.heredoc.coffee', 'punctuation.definition.string.begin.coffee']
-          expect(tokens[1]).toEqual value: "single-quoted heredoc", scopes: ['source.coffee', 'string.quoted.heredoc.coffee']
-          expect(tokens[2]).toEqual value: "'''", scopes: ['source.coffee', 'string.quoted.heredoc.coffee', 'punctuation.definition.string.end.coffee']
+        expect(tokens[0]).toEqual value: "'''", scopes: ['source.coffee', 'string.quoted.heredoc.coffee', 'punctuation.definition.string.begin.coffee']
+        expect(tokens[1]).toEqual value: "single-quoted heredoc", scopes: ['source.coffee', 'string.quoted.heredoc.coffee']
+        expect(tokens[2]).toEqual value: "'''", scopes: ['source.coffee', 'string.quoted.heredoc.coffee', 'punctuation.definition.string.end.coffee']
+
+    describe "when begin/end pattern spans multiple lines", ->
+      it "uses the currentRule returned by the first line to parse the second line", ->
+        {tokens: firstTokens, currentRule} = parser.getLineTokens("'''single-quoted")
+        {tokens: secondTokens, currentRule} = parser.getLineTokens("heredoc'''", currentRule)
+
+        expect(firstTokens.length).toBe 2
+        expect(secondTokens.length).toBe 2
+
+        expect(firstTokens[0]).toEqual value: "'''", scopes: ['source.coffee', 'string.quoted.heredoc.coffee', 'punctuation.definition.string.begin.coffee']
+        expect(firstTokens[1]).toEqual value: "single-quoted", scopes: ['source.coffee', 'string.quoted.heredoc.coffee']
+
+        expect(secondTokens[0]).toEqual value: "heredoc", scopes: ['source.coffee', 'string.quoted.heredoc.coffee']
+        expect(secondTokens[1]).toEqual value: "'''", scopes: ['source.coffee', 'string.quoted.heredoc.coffee', 'punctuation.definition.string.end.coffee']
+
+   describe "when the line matches a begin/end pattern that contains sub-patterns", ->
+     it "returns tokens within the begin/end scope based on the sub-patterns", ->
+       {tokens, currentRule} = parser.getLineTokens('"""heredoc with character escape \\t"""')
+
+       expect(tokens.length).toBe 4
+
+       expect(tokens[0]).toEqual value: '"""', scopes: ['source.coffee', 'string.quoted.double.heredoc.coffee', 'punctuation.definition.string.begin.coffee']
+       expect(tokens[1]).toEqual value: "heredoc with character escape ", scopes: ['source.coffee', 'string.quoted.double.heredoc.coffee']
+       expect(tokens[2]).toEqual value: "\\t", scopes: ['source.coffee', 'string.quoted.double.heredoc.coffee', 'constant.character.escape.coffee']
+       expect(tokens[3]).toEqual value: '"""', scopes: ['source.coffee', 'string.quoted.double.heredoc.coffee', 'punctuation.definition.string.end.coffee']