ver 2010.02 → 2010.08

data/config/syntax/Grails Server Page.rb

@@ -0,0 +1,108 @@
+# Encoding: UTF-8
+
+{fileTypes: ["gsp"],
+ foldingStartMarker: 
+  /(?x)
+	(?<_1><(?i:head|body|table|thead|tbody|tfoot|tr|div|select|fieldset|style|script|ul|ol|form|dl|g:javascript)\b.*?>
+	|<!--(?!.*-->)
+	|\{\s*(?<_2>$|\?>\s*$|\/\/|\/\*(?<_3>.*\*\/\s*$|(?!.*?\*\/)))
+	)/,
+ foldingStopMarker: 
+  /(?x)
+	(?<_1><\/(?i:head|body|table|thead|tbody|tfoot|tr|div|select|fieldset|style|script|ul|ol|form|dl|g:javascript)>
+	|^\s*-->
+	|(?<_2>^|\s)\}
+	)/,
+ keyEquivalent: "^~G",
+ name: "Grails Server Page",
+ patterns: 
+  [{begin: /<%+(?!>)=?/,
+    beginCaptures: {0 => {name: "punctuation.section.embedded.begin.groovy"}},
+    end: "(%)>",
+    endCaptures: 
+     {0 => {name: "punctuation.section.embedded.end.groovy"},
+      1 => {name: "source.groovy"}},
+    name: "source.groovy",
+    patterns: [{include: "source.groovy"}]},
+   {include: "#embedded-groovy"},
+   {begin: /(?<_1>^\s*)?(?=<(?i:g:javascript))/,
+    beginCaptures: {0 => {name: "punctuation.whitespace.embedded.leading.js"}},
+    contentName: "source.js",
+    end: "(?<=>)(?!<(?i:g:javascript))(\\s*\\n)?",
+    endCaptures: {0 => {name: "punctuation.whitespace.embedded.trailing.js"}},
+    patterns: 
+     [{begin: /(?<_1><)(?<_2>(?i:g:javascript))/,
+       beginCaptures: 
+        {1 => {name: "punctuation.definition.tag.html.grails"},
+         2 => {name: "entity.name.tag.template.html.grails"}},
+       end: "/>|(?=>)",
+       endCaptures: {0 => {name: "punctuation.definition.tag.html.grails"}},
+       name: "meta.tag.template.javascript.html.grails",
+       patterns: [{include: "#tag-stuff"}]},
+      {captures: 
+        {1 => {name: "punctuation.definition.tag.html.grails"},
+         2 => {name: "source.js"},
+         3 => {name: "entity.name.tag.template.html.grails"},
+         4 => {name: "punctuation.definition.tag.html.grails"}},
+       match: /(?<_1>(?<_2><)\/)(?<_3>(?i:g:javascript))(?<_4>>)/,
+       name: "meta.tag.template.javascript.html.grails"},
+      {begin: /(?<_1>>)/,
+       beginCaptures: 
+        {0 => {name: "meta.tag.template.javascript.html.grails"},
+         1 => {name: "punctuation.definition.tag.html.grails"}},
+       contentName: "source.js",
+       end: "(?=</(?i:g:javascript)>)",
+       patterns: 
+        [{captures: {1 => {name: "punctuation.definition.comment.begin.js"}},
+          match: /(?<_1>\/\/).*?(?<_2>(?=<\/(?i:g:javascript))|$\n?)/,
+          name: "comment.line.double-slash.js"},
+         {begin: /\/\*/,
+          beginCaptures: 
+           {0 => {name: "punctuation.definition.comment.begin.js"}},
+          end: "\\*/|(?=</(?i:g:javascript))",
+          endCaptures: {0 => {name: "punctuation.definition.comment.end.js"}},
+          name: "comment.block.js"},
+         {include: "source.js"}]}]},
+   {begin: /(?<_1><\/?)(?<_2>\w+:\w+)/,
+    captures: 
+     {1 => {name: "punctuation.definition.tag.html.grails"},
+      2 => {name: "entity.name.tag.template.html.grails"}},
+    end: "(/?>)",
+    name: "meta.tag.template.html.grails",
+    patterns: [{include: "#tag-stuff"}]},
+   {include: "text.html.basic"}],
+ repository: 
+  {:"embedded-groovy" => 
+    {patterns: 
+      [{begin: /\$\{/,
+        captures: {0 => {name: "punctuation.section.embedded.groovy"}},
+        end: "\\}",
+        name: "source.groovy.embedded.html.grails",
+        patterns: [{include: "source.groovy"}]}]},
+   :"string-double-quoted" => 
+    {begin: /"/,
+     beginCaptures: 
+      {0 => {name: "punctuation.definition.string.begin.html.grails"}},
+     end: "\"",
+     endCaptures: 
+      {0 => {name: "punctuation.definition.string.end.html.grails"}},
+     name: "string.quoted.double.html.grails",
+     patterns: [{include: "#embedded-groovy"}]},
+   :"string-single-quoted" => 
+    {begin: /'/,
+     beginCaptures: 
+      {0 => {name: "punctuation.definition.string.begin.html.grails"}},
+     end: "'",
+     endCaptures: 
+      {0 => {name: "punctuation.definition.string.end.html.grails"}},
+     name: "string.quoted.single.html.grails"},
+   :"tag-attribute" => 
+    {match: /\b(?<_1>[a-zA-Z\-:]+)/,
+     name: "entity.other.attribute-name.html.grails"},
+   :"tag-stuff" => 
+    {patterns: 
+      [{include: "#tag-attribute"},
+       {include: "#string-double-quoted"},
+       {include: "#string-single-quoted"}]}},
+ scopeName: "text.html.grails",
+ uuid: "E4DECA1B-424C-4A75-AD67-E907F182E4FB"}

data/config/syntax/Graphviz (DOT).rb

@@ -6,16 +6,16 @@
  keyEquivalent: "^~G",
  name: "Graphviz (DOT)",
  patterns: 
-  [{match: /\b(node|edge|graph|digraph|subgraph|strict)\b/,
+  [{match: /\b(?<_1>node|edge|graph|digraph|subgraph|strict)\b/,
     name: "storage.type.dot"},
    {match: 
-     /\b(bottomlabel|color|comment|distortion|fillcolor|fixedsize|fontcolor|fontname|fontsize|group|height|label|layer|orientation|peripheries|regular|shape|shapefile|sides|skew|style|toplabel|URL|width|z)\b/,
+     /\b(?<_1>bottomlabel|color|comment|distortion|fillcolor|fixedsize|fontcolor|fontname|fontsize|group|height|label|layer|orientation|peripheries|regular|shape|shapefile|sides|skew|style|toplabel|URL|width|z)\b/,
     name: "support.constant.attribute.node.dot"},
    {match: 
-     /\b(arrowhead|arrowsize|arrowtail|color|comment|constraint|decorate|dir|fontcolor|fontname|fontsize|headlabel|headport|headURL|label|labelangle|labeldistance|labelfloat|labelcolor|labelfontname|labelfontsize|layer|lhead|ltail|minlen|samehead|sametail|style|taillabel|tailport|tailURL|weight)\b/,
+     /\b(?<_1>arrowhead|arrowsize|arrowtail|color|comment|constraint|decorate|dir|fontcolor|fontname|fontsize|headlabel|headport|headURL|label|labelangle|labeldistance|labelfloat|labelcolor|labelfontname|labelfontsize|layer|lhead|ltail|minlen|samehead|sametail|style|taillabel|tailport|tailURL|weight)\b/,
     name: "support.constant.attribute.edge.dot"},
    {match: 
-     /\b(bgcolor|center|clusterrank|color|comment|compound|concentrate|fillcolor|fontname|fontpath|fontsize|label|labeljust|labelloc|layers|margin|mclimit|nodesep|nslimit|nslimit1|ordering|orientation|page|pagedir|quantum|rank|rankdir|ranksep|ratio|remincross|rotate|samplepoints|searchsize|size|style|URL)\b/,
+     /\b(?<_1>bgcolor|center|clusterrank|color|comment|compound|concentrate|fillcolor|fontname|fontpath|fontsize|label|labeljust|labelloc|layers|margin|mclimit|nodesep|nslimit|nslimit1|ordering|orientation|page|pagedir|quantum|rank|rankdir|ranksep|ratio|remincross|rotate|samplepoints|searchsize|size|style|URL)\b/,
     name: "support.constant.attribute.graph.dot"},
    {begin: /"/,
     beginCaptures: {0 => {name: "punctuation.definition.string.begin.dot"}},
@@ -24,10 +24,10 @@
     name: "string.quoted.double.dot",
     patterns: [{match: /\\./, name: "constant.character.escape.dot"}]},
    {captures: {1 => {name: "punctuation.definition.comment.dot"}},
-    match: /(\/\/).*$\n?/,
+    match: /(?<_1>\/\/).*$\n?/,
     name: "comment.line.double-slash.dot"},
    {captures: {1 => {name: "punctuation.definition.comment.dot"}},
-    match: /(#).*$\n?/,
+    match: /(?<_1>#).*$\n?/,
     name: "comment.line.number-sign.dot"},
    {begin: /\/\*/,
     captures: {0 => {name: "punctuation.definition.comment.dot"}},

data/config/syntax/Greasemonkey.rb

@@ -9,7 +9,7 @@
  patterns: 
   [{match: /\bunsafeWindow\b/, name: "support.class.greasemonkey"},
    {match: 
-     /\bGM_(registerMenuCommand|xmlhttpRequest|setValue|getValue|log|openInTab|addStyle)\b(?=\()/,
+     /\bGM_(?<_1>registerMenuCommand|xmlhttpRequest|setValue|getValue|log|openInTab|addStyle)\b(?=\()/,
     name: "support.function.greasemonkey"},
    {begin: /\/\/ ==UserScript==/,
     end: "// ==/UserScript==\\s*",
@@ -19,12 +19,12 @@
         {1 => {name: "keyword.other.greasemonkey"},
          3 => {name: "string.unquoted.greasemonkey"}},
        match: 
-        /\/\/ (@(name|namespace|description|include|exclude))\b\s*(.+\s+)?/,
+        /\/\/ (?<_1>@(?<_2>name|namespace|description|include|exclude))\b\s*(?<_3>.+\s+)?/,
        name: "meta.directive.standard.greasemonkey"},
       {captures: 
         {1 => {name: "keyword.other.greasemonkey"},
          3 => {name: "string.unquoted.greasemonkey"}},
-       match: /\/\/ (@(\S+))\b\s*(.+\s+)?/,
+       match: /\/\/ (?<_1>@(?<_2>\S+))\b\s*(?<_3>.+\s+)?/,
        name: "meta.directive.nonstandard.greasemonkey"}]},
    {include: "source.js"}],
  scopeName: "source.js.greasemonkey",

data/config/syntax/Gri.rb

@@ -2,15 +2,15 @@
 
 {fileTypes: ["gri"],
  firstLineMatch: "-[*]-( Mode:)? Gri -[*]-",
- foldingStartMarker: /(\/\*\*|\{\s*$)/,
- foldingStopMarker: /(\*\*\/|^\s*\})/,
+ foldingStartMarker: /(?<_1>\/\*\*|\{\s*$)/,
+ foldingStopMarker: /(?<_1>\*\*\/|^\s*\})/,
  name: "Gri",
  patterns: 
   [{captures: 
      {1 => {name: "punctuation.definition.function.gri"},
       2 => {name: "entity.name.function.gri"},
       3 => {name: "punctuation.definition.function.gri"}},
-    match: /(\`)(.*)(')/,
+    match: /(?<_1>\`)(?<_2>.*)(?<_3>')/,
     name: "meta.function.gri"},
    {begin: /#/,
     beginCaptures: {0 => {name: "punctuation.definition.comment.gri"}},
@@ -24,33 +24,33 @@
     name: "comment.line.double-slash.gri",
     patterns: 
      [{match: /(?>\\\s*\n)/, name: "punctuation.separator.continuation.gri"}]},
-   {match: /\b(break|else|end|if|return|rpn|while)\b/,
+   {match: /\b(?<_1>break|else|end|if|return|rpn|while)\b/,
     name: "keyword.control.gri"},
-   {match: /(\-|\+|\*|\/|%\/%|%%|\^)/,
+   {match: /(?<_1>\-|\+|\*|\/|%\/%|%%|\^)/,
     name: "keyword.operator.arithmetic.gri"},
-   {match: /(=|<-)/, name: "keyword.operator.assignment.gri"},
-   {match: /(==|!=)/, name: "keyword.operator.comparison.gri"},
+   {match: /(?<_1>=|<-)/, name: "keyword.operator.assignment.gri"},
+   {match: /(?<_1>==|!=)/, name: "keyword.operator.comparison.gri"},
    {match: 
-     /\b((0(x|X)[0-9a-fA-F]*)|(([0-9]+\.?[0-9]*)|(\.[0-9]+))((e|E)(\+|-)?[0-9]+)?)\b/,
+     /\b(?<_1>(?<_2>0(?<_3>x|X)[0-9a-fA-F]*)|(?<_4>(?<_5>[0-9]+\.?[0-9]*)|(?<_6>\.[0-9]+))(?<_7>(?<_8>e|E)(?<_9>\+|-)?[0-9]+)?)\b/,
     name: "constant.numeric.gri"},
-   {begin: /(<< *")([^"]*)(")/,
+   {begin: /(?<_1><< *")(?<_2>[^"]*)(?<_3>")/,
     captures: 
      {1 => {name: "punctuation.definition.heredoc.gri"},
       3 => {name: "punctuation.definition.heredoc.gri"}},
     end: "^\\2$",
     name: "string.unquoted.heredoc.doublequote.gri"},
    {captures: {1 => {name: "punctuation.definition.variable.gri"}},
-    match: /(\\)[\.a-zA-Z0-9_][\.a-zA-Z0-9_]*\b/,
+    match: /(?<_1>\\)[\.a-zA-Z0-9_][\.a-zA-Z0-9_]*\b/,
     name: "variable.other.synonym.gri"},
    {captures: 
      {1 => {name: "punctuation.definition.variable.gri"},
       2 => {name: "punctuation.definition.variable.gri"}},
-    match: /(\.)[a-zA-Z0-9_][a-zA-Z0-9_]*(\.)/,
+    match: /(?<_1>\.)[a-zA-Z0-9_][a-zA-Z0-9_]*(?<_2>\.)/,
     name: "variable.other.variable.gri"},
    {captures: 
      {1 => {name: "punctuation.definition.variable.gri"},
       2 => {name: "punctuation.definition.variable.gri"}},
-    match: /(\.\.)[a-zA-Z0-9_][a-zA-Z0-9_]*(\.\.)/,
+    match: /(?<_1>\.\.)[a-zA-Z0-9_][a-zA-Z0-9_]*(?<_2>\.\.)/,
     name: "variable.other.variabledot.gri"},
    {begin: /"/,
     beginCaptures: {0 => {name: "punctuation.definition.string.begin.gri"}},

data/config/syntax/Groovy.rb

@@ -0,0 +1,502 @@
+# Encoding: UTF-8
+
+{fileTypes: ["groovy", "gvy"],
+ foldingStartMarker: /(?<_1>\{\s*$|^\s*\/\/ \{\{\{)/,
+ foldingStopMarker: /^\s*(?<_1>\}|\/\/ \}\}\}$)/,
+ keyEquivalent: "^~G",
+ name: "Groovy",
+ patterns: 
+  [{captures: {1 => {name: "punctuation.definition.comment.groovy"}},
+    match: /^(?<_1>#!).+$\n/,
+    name: "comment.line.hashbang.groovy"},
+   {captures: 
+     {1 => {name: "keyword.other.package.groovy"},
+      2 => {name: "storage.modifier.package.groovy"},
+      3 => {name: "punctuation.terminator.groovy"}},
+    match: /^\s*(?<_1>package)\b(?:\s*(?<_2>[^ ;$]+)\s*(?<_3>;)?)?/,
+    name: "meta.package.groovy"},
+   {captures: 
+     {1 => {name: "keyword.other.import.groovy"},
+      2 => {name: "keyword.other.import.static.groovy"},
+      3 => {name: "storage.modifier.import.groovy"},
+      4 => {name: "punctuation.terminator.groovy"}},
+    match: 
+     /^\s*(?<_1>import)(?:\s+(?<_2>static)\s+)\b(?:\s*(?<_3>[^ ;$]+)\s*(?<_4>;)?)?/,
+    name: "meta.import.static.groovy"},
+   {captures: 
+     {1 => {name: "keyword.other.import.groovy"},
+      2 => {name: "storage.modifier.import.groovy"},
+      3 => {name: "punctuation.terminator.groovy"}},
+    match: /^\s*(?<_1>import)\b(?:\s*(?<_2>[^ ;$]+)\s*(?<_3>;)?)?/,
+    name: "meta.import.groovy"},
+   {captures: 
+     {1 => {name: "keyword.other.import.groovy"},
+      2 => {name: "keyword.other.import.static.groovy"},
+      3 => {name: "storage.modifier.import.groovy"},
+      4 => {name: "punctuation.terminator.groovy"}},
+    match: 
+     /^\s*(?<_1>import)(?:\s+(?<_2>static)\s+)\b(?:\s*(?<_3>[^ ;$]+)\s*(?<_4>;)?)?/,
+    name: "meta.import.groovy"},
+   {include: "#groovy"}],
+ repository: 
+  {annotations: 
+    {patterns: 
+      [{begin: /(?<!\.)(?<_1>@[^ (?<_2>]+)(?<_3>\()/,
+        beginCaptures: 
+         {1 => {name: "storage.type.annotation.groovy"},
+          2 => 
+           {name: "punctuation.definition.annotation-arguments.begin.groovy"}},
+        end: "(\\))",
+        endCaptures: 
+         {1 => 
+           {name: "punctuation.definition.annotation-arguments.end.groovy"}},
+        name: "meta.declaration.annotation.groovy",
+        patterns: 
+         [{captures: 
+            {1 => {name: "constant.other.key.groovy"},
+             2 => {name: "keyword.operator.assignment.groovy"}},
+           match: /(?<_1>\w*)\s*(?<_2>=)/},
+          {include: "#values"},
+          {match: /,/, name: "punctuation.definition.seperator.groovy"}]},
+       {match: /(?<!\.)@\S+/, name: "storage.type.annotation.groovy"}]},
+   braces: {begin: /\{/, end: "\\}", patterns: [{include: "#groovy-code"}]},
+   class: 
+    {begin: /(?=\w?[\w\s]*(?:class|(?:@)?interface|enum)\s+\w+)/,
+     end: "}",
+     endCaptures: {0 => {name: "punctuation.section.class.end.groovy"}},
+     name: "meta.definition.class.groovy",
+     patterns: 
+      [{include: "#storage-modifiers"},
+       {include: "#comments"},
+       {captures: 
+         {1 => {name: "storage.modifier.groovy"},
+          2 => {name: "entity.name.type.class.groovy"}},
+        match: /(?<_1>class|(?:@)?interface|enum)\s+(?<_2>\w+)/,
+        name: "meta.class.identifier.groovy"},
+       {begin: /extends/,
+        beginCaptures: {0 => {name: "storage.modifier.extends.groovy"}},
+        end: "(?={|implements)",
+        name: "meta.definition.class.inherited.classes.groovy",
+        patterns: 
+         [{include: "#object-types-inherited"}, {include: "#comments"}]},
+       {begin: /(?<_1>implements)\s/,
+        beginCaptures: {1 => {name: "storage.modifier.implements.groovy"}},
+        end: "(?=\\s*extends|\\{)",
+        name: "meta.definition.class.implemented.interfaces.groovy",
+        patterns: 
+         [{include: "#object-types-inherited"}, {include: "#comments"}]},
+       {begin: /{/,
+        end: "(?=})",
+        name: "meta.class.body.groovy",
+        patterns: [{include: "#groovy"}]}]},
+   :"class-variables" => 
+    {patterns: 
+      [{begin: /\b(?!as)(?=\w[\w\[\]<>,]*?\s\w)/,
+        end: ";|$",
+        name: "meta.definition.class-variable.groovy",
+        patterns: 
+         [{captures: {1 => {name: "constant.class-variable.groovy"}},
+           match: /(?<_1>[A-Z_0-9]+)\s+(?=\=)/},
+          {captures: 
+            {1 => {name: "meta.definition.class-variable.name.groovy"}},
+           match: /(?<_1>\w[^\s,]*)\s+(?=\=)/},
+          {begin: /=/,
+           beginCaptures: {0 => {name: "keyword.operator.assignment.groovy"}},
+           end: "$",
+           patterns: [{include: "#groovy-code"}]},
+          {captures: 
+            {1 => {name: "meta.definition.class-variable.name.groovy"}},
+           match: /(?<_1>\w\S*)(?=\s*(?<_2>$|;))/},
+          {include: "#groovy-code"}]}]},
+   closures: 
+    {begin: /\{(?=.*->)/,
+     end: "\\}",
+     patterns: 
+      [{begin: /(?!->)/,
+        end: "(?=->)",
+        patterns: 
+         [{begin: /(?!->)/,
+           end: "(?=->)",
+           name: "meta.closure.parameters.groovy",
+           patterns: 
+            [{begin: /(?!,|->)/,
+              end: "(?=,|->)",
+              name: "meta.closure.parameter.groovy",
+              patterns: 
+               [{begin: /=/,
+                 beginCaptures: 
+                  {0 => {name: "keyword.operator.assignment.groovy"}},
+                 end: "(?=,|->)",
+                 name: "meta.parameter.default.groovy",
+                 patterns: [{include: "#groovy-code"}]},
+                {include: "#parameters"}]}]}]},
+       {begin: /->/,
+        beginCaptures: {0 => {name: "keyword.operator.groovy"}},
+        end: "(?=\\})",
+        patterns: [{include: "#groovy-code"}]}]},
+   :"comment-block" => 
+    {begin: /\/\*/,
+     captures: {0 => {name: "punctuation.definition.comment.groovy"}},
+     end: "\\*/",
+     name: "comment.block.groovy"},
+   comments: 
+    {patterns: 
+      [{captures: {0 => {name: "punctuation.definition.comment.groovy"}},
+        match: /\/\*\*\//,
+        name: "comment.block.empty.groovy"},
+       {include: "text.html.javadoc"},
+       {include: "#comment-block"},
+       {captures: {1 => {name: "punctuation.definition.comment.groovy"}},
+        match: /(?<_1>\/\/).*$\n?/,
+        name: "comment.line.double-slash.groovy"}]},
+   constants: 
+    {patterns: 
+      [{match: /\b(?<_1>[A-Z][A-Z0-9_]+)\b/, name: "constant.other.groovy"},
+       {match: /\b(?<_1>true|false|null)\b/,
+        name: "constant.language.groovy"}]},
+   :"enum-values" => 
+    {patterns: 
+      [{begin: /\b[A-Z0-9_]*(?=\s*(?:,|;|}|\(|$))/,
+        beginCaptures: {0 => {name: "constant.enum.name.groovy"}},
+        end: ",|;|(?=})|^(?!\\s*\\w+\\s*(?:,|$))",
+        patterns: 
+         [{begin: /\(/,
+           end: "\\)",
+           name: "meta.enum.value.groovy",
+           patterns: [{include: "#values"}]}]}]},
+   groovy: 
+    {patterns: 
+      [{include: "#comments"},
+       {include: "#annotations"},
+       {include: "#class"},
+       {include: "#enum-values"},
+       {include: "#methods"},
+       {include: "#class-variables"},
+       {include: "#groovy-code"}]},
+   :"groovy-code" => 
+    {patterns: 
+      [{include: "#groovy-code-minus-map-keys"}, {include: "#map-keys"}]},
+   :"groovy-code-minus-map-keys" => 
+    {comment: 
+      "In some situations, maps can't be declared without enclosing []'s, \n\t\t\t\ttherefore we create a collection of everything but that",
+     patterns: 
+      [{include: "#comments"},
+       {include: "#annotations"},
+       {include: "#support-functions"},
+       {include: "#keyword-language"},
+       {include: "#values"},
+       {include: "#keyword-operator"},
+       {include: "#types"},
+       {include: "#storage-modifiers"},
+       {include: "#parens"},
+       {include: "#closures"},
+       {include: "#braces"}]},
+   keyword: 
+    {patterns: 
+      [{include: "#keyword-operator"}, {include: "#keyword-language"}]},
+   :"keyword-language" => 
+    {patterns: 
+      [{match: /\b(?<_1>try|catch|finally|throw)\b/,
+        name: "keyword.control.exception.groovy"},
+       {match: 
+         /\b(?<_1>(?<!\.)(?:return|break|continue|default|do|while|for|switch|if|else))\b/,
+        name: "keyword.control.groovy"},
+       {begin: /\bcase\b/,
+        beginCaptures: {0 => {name: "keyword.control.groovy"}},
+        end: ":",
+        endCaptures: 
+         {0 => {name: "punctuation.definition.case-terminator.groovy"}},
+        name: "meta.case.groovy",
+        patterns: [{include: "#groovy-code-minus-map-keys"}]},
+       {match: /\b(?<_1>new)\b/, name: "keyword.other.new.groovy"},
+       {begin: /\b(?<_1>assert)\s/,
+        beginCaptures: {1 => {name: "keyword.control.assert.groovy"}},
+        end: "$",
+        name: "meta.declaration.assertion.groovy",
+        patterns: 
+         [{match: /:/,
+           name: "keyword.operator.assert.expression-seperator.groovy"},
+          {include: "#groovy-code-minus-map-keys"}]},
+       {match: /\b(?<_1>throws)\b/, name: "keyword.other.throws.groovy"}]},
+   :"keyword-operator" => 
+    {patterns: 
+      [{match: /\b(?<_1>as)\b/, name: "keyword.operator.as.groovy"},
+       {match: /\b(?<_1>is)\b/, name: "keyword.operator.is.groovy"},
+       {match: /\?\:/, name: "keyword.operator.elvis.groovy"},
+       {match: /\.\./, name: "keyword.operator.range.groovy"},
+       {match: /\->/, name: "keyword.operator.arrow.groovy"},
+       {match: /<</, name: "keyword.operator.leftshift.groovy"},
+       {match: /(?<=\S)\.(?=\S)/, name: "keyword.operator.navigation.groovy"},
+       {match: /(?<=\S)\?\.(?=\S)/,
+        name: "keyword.operator.safe-navigation.groovy"},
+       {begin: /\?/,
+        beginCaptures: {0 => {name: "keyword.operator.ternary.groovy"}},
+        end: "(?=$|\\)|})",
+        name: "meta.evaluation.ternary.groovy",
+        patterns: 
+         [{match: /:/,
+           name: "keyword.operator.ternary.expression-seperator.groovy"},
+          {include: "#groovy-code-minus-map-keys"}]},
+       {match: /==~/, name: "keyword.operator.match.groovy"},
+       {match: /=~/, name: "keyword.operator.find.groovy"},
+       {match: /\b(?<_1>instanceof)\b/,
+        name: "keyword.operator.instanceof.groovy"},
+       {match: /(?<_1>===|==|!=|<=|>=|<=>|<>|<|>|<<)/,
+        name: "keyword.operator.comparison.groovy"},
+       {match: /=/, name: "keyword.operator.assignment.groovy"},
+       {match: /(?<_1>\-\-|\+\+)/,
+        name: "keyword.operator.increment-decrement.groovy"},
+       {match: /(?<_1>\-|\+|\*|\/|%)/,
+        name: "keyword.operator.arithmetic.groovy"},
+       {match: /(?<_1>!|&&|\|\|)/, name: "keyword.operator.logical.groovy"}]},
+   :"map-keys" => 
+    {patterns: 
+      [{captures: 
+         {1 => {name: "constant.other.key.groovy"},
+          2 => {name: "punctuation.definition.seperator.key-value.groovy"}},
+        match: /(?<_1>\w+)\s*(?<_2>:)/}]},
+   :"method-call" => 
+    {begin: /(?<_1>\w+)(?<_2>\()/,
+     beginCaptures: 
+      {1 => {name: "meta.method.groovy"},
+       2 => {name: "punctuation.definition.method-parameters.begin.groovy"}},
+     end: "\\)",
+     endCaptures: 
+      {0 => {name: "punctuation.definition.method-parameters.end.groovy"}},
+     name: "meta.method-call.groovy",
+     patterns: 
+      [{match: /,/, name: "punctuation.definition.seperator.parameter.groovy"},
+       {include: "#groovy-code"}]},
+   methods: 
+    {applyEndPatternLast: 1,
+     begin: 
+      /(?x:
+	    (?<!\.)\b # not preceeded by . (?<_1>method call)
+	    (?!new) # not before new
+	    (?= # looking forward we see
+	        (?:
+	            (?:\w|<)\S* # a word (?<_2>modifier or return type) or a parameter type
+	            \s+ # some space
+	            (?:\w|<)\S*[^=\.\s]*? # another word and anything but =, . or space
+	            | # or
+	            [A-Z_]\w* # a capitalised word (?<_3>i.e. constructor name)
+	        )
+	        \( # and the leading parens of the params
+	    )
+	)/,
+     end: "}|(?=(^\\s*)?[^{])",
+     name: "meta.definition.method.groovy",
+     patterns: 
+      [{match: /\s/},
+       {include: "#storage-modifiers"},
+       {begin: /(?<_1>\w+)\s*\(/,
+        beginCaptures: {1 => {name: "entity.name.function.java"}},
+        end: "\\)",
+        name: "meta.definition.method.signature.java",
+        patterns: 
+         [{begin: /(?=[^)])/,
+           end: "(?=\\))",
+           name: "meta.method.parameters.groovy",
+           patterns: 
+            [{begin: /(?=[^,)])/,
+              end: "(?=,|\\))",
+              name: "meta.method.parameter.groovy",
+              patterns: 
+               [{match: /,/, name: "punctuation.definition.separator.groovy"},
+                {begin: /=/,
+                 beginCaptures: 
+                  {0 => {name: "keyword.operator.assignment.groovy"}},
+                 end: "(?=,|\\))",
+                 name: "meta.parameter.default.groovy",
+                 patterns: [{include: "#groovy-code"}]},
+                {include: "#parameters"}]}]}]},
+       {begin: /(?=<)/,
+        end: "(?=\\s)",
+        name: "meta.method.paramerised-type.groovy",
+        patterns: 
+         [{begin: /</,
+           end: ">",
+           name: "storage.type.parameters.groovy",
+           patterns: 
+            [{include: "#types"},
+             {match: /,/, name: "punctuation.definition.seperator.groovy"}]}]},
+       {begin: /(?=(?:\w|<).*\s+(?:\w|<)+\s*\()/,
+        end: "(?=\\w+\\s*\\()",
+        name: "meta.method.return-type.java",
+        patterns: [{include: "#types"}]},
+       {begin: /throws/,
+        beginCaptures: {0 => {name: "storage.modifier.groovy"}},
+        end: "(?={|;)|^(?=\\s*(?:[^{\\s]|$))",
+        name: "meta.throwables.groovy",
+        patterns: [{include: "#object-types"}]},
+       {begin: /{/,
+        end: "(?=})",
+        name: "meta.method.body.java",
+        patterns: [{include: "#groovy-code"}]}]},
+   nest_curly: 
+    {begin: /\{/,
+     captures: {0 => {name: "punctuation.section.scope.groovy"}},
+     end: "\\}",
+     patterns: [{include: "#nest_curly"}]},
+   numbers: 
+    {patterns: 
+      [{match: 
+         /(?<_1>(?<_2>0(?<_3>x|X)[0-9a-fA-F]*)|(?<_4>\+|-)?\b(?<_5>(?<_6>[0-9]+\.?[0-9]*)|(?<_7>\.[0-9]+))(?<_8>(?<_9>e|E)(?<_10>\+|-)?[0-9]+)?)(?<_11>[LlFfUuDd]|UL|ul)?\b/,
+        name: "constant.numeric.groovy"}]},
+   :"object-types" => 
+    {patterns: 
+      [{begin: /\b(?<_1>(?:[a-z]\w*\.)*[A-Z]+\w*)</,
+        end: ">|[^\\w\\s,\\?<\\[\\]]",
+        name: "storage.type.generic.groovy",
+        patterns: 
+         [{include: "#object-types"},
+          {begin: /</,
+           comment: "This is just to support <>'s with no actual type prefix",
+           end: ">|[^\\w\\s,\\[\\]<]",
+           name: "storage.type.generic.groovy"}]},
+       {begin: /\b(?<_1>(?:[a-z]\w*\.)*[A-Z]+\w*)(?=\[)/,
+        end: "(?=[^\\]\\s])",
+        name: "storage.type.object.array.groovy",
+        patterns: 
+         [{begin: /\[/, end: "\\]", patterns: [{include: "#groovy"}]}]},
+       {captures: {1 => {name: "keyword.operator.dereference.groovy"}},
+        match: /\b(?:[a-z]\w*(?<_1>\.))*[A-Z]+\w*\b/,
+        name: "storage.type.groovy"}]},
+   :"object-types-inherited" => 
+    {patterns: 
+      [{begin: /\b(?<_1>(?:[a-z]\w*\.)*[A-Z]+\w*)</,
+        end: ">|[^\\w\\s,\\?<\\[\\]]",
+        name: "entity.other.inherited-class.groovy",
+        patterns: 
+         [{include: "#object-types-inherited"},
+          {begin: /</,
+           comment: "This is just to support <>'s with no actual type prefix",
+           end: ">|[^\\w\\s,\\[\\]<]",
+           name: "storage.type.generic.groovy"}]},
+       {captures: {1 => {name: "keyword.operator.dereference.groovy"}},
+        match: /\b(?:[a-z]\w*(?<_1>\.))*[A-Z]+\w*\b/,
+        name: "entity.other.inherited-class.groovy"}]},
+   parameters: 
+    {patterns: 
+      [{include: "#annotations"},
+       {include: "#storage-modifiers"},
+       {include: "#types"},
+       {match: /\w+/, name: "variable.parameter.method.groovy"}]},
+   parens: {begin: /\(/, end: "\\)", patterns: [{include: "#groovy-code"}]},
+   :"primitive-arrays" => 
+    {patterns: 
+      [{match: 
+         /\b(?:void|boolean|byte|char|short|int|float|long|double)(?<_1>\[\])*\b/,
+        name: "storage.type.primitive.array.groovy"}]},
+   :"primitive-types" => 
+    {patterns: 
+      [{match: /\b(?:void|boolean|byte|char|short|int|float|long|double)\b/,
+        name: "storage.type.primitive.groovy"}]},
+   regexp: 
+    {patterns: 
+      [{begin: /\/(?=[^\/]+\/)/,
+        beginCaptures: 
+         {0 => {name: "punctuation.definition.string.regexp.begin.groovy"}},
+        end: "/",
+        endCaptures: 
+         {0 => {name: "punctuation.definition.string.regexp.end.groovy"}},
+        name: "string.regexp.groovy",
+        patterns: 
+         [{match: /\\./, name: "constant.character.escape.groovy"}]}]},
+   :"storage-modifiers" => 
+    {patterns: 
+      [{match: /\b(?<_1>private|protected|public)\b/,
+        name: "storage.modifier.access-control.groovy"},
+       {match: /\b(?<_1>static)\b/, name: "storage.modifier.static.groovy"},
+       {match: /\b(?<_1>final)\b/, name: "storage.modifier.final.groovy"},
+       {match: /\b(?<_1>native|synchronized|abstract|threadsafe|transient)\b/,
+        name: "storage.modifier.other.groovy"}]},
+   :"string-quoted-double" => 
+    {begin: /"/,
+     beginCaptures: 
+      {0 => {name: "punctuation.definition.string.begin.groovy"}},
+     end: "\"",
+     endCaptures: {0 => {name: "punctuation.definition.string.end.groovy"}},
+     name: "string.quoted.double.groovy",
+     patterns: [{include: "#string-quoted-double-contents"}]},
+   :"string-quoted-double-contents" => 
+    {patterns: 
+      [{match: /\\./, name: "constant.character.escape.groovy"},
+       {match: /\$\w+/, name: "variable.other.interpolated.groovy"},
+       {begin: /\$\{/,
+        captures: {0 => {name: "punctuation.section.embedded.groovy"}},
+        end: "\\}",
+        name: "source.groovy.embedded.source",
+        patterns: [{include: "#nest_curly"}]}]},
+   :"string-quoted-double-multiline" => 
+    {begin: /"""/,
+     beginCaptures: 
+      {0 => {name: "punctuation.definition.string.begin.groovy"}},
+     end: "\"\"\"",
+     endCaptures: {0 => {name: "punctuation.definition.string.end.groovy"}},
+     name: "string.quoted.double.multiline.groovy",
+     patterns: [{include: "#string-quoted-double-contents"}]},
+   :"string-quoted-single" => 
+    {begin: /'/,
+     beginCaptures: 
+      {0 => {name: "punctuation.definition.string.begin.groovy"}},
+     end: "'",
+     endCaptures: {0 => {name: "punctuation.definition.string.end.groovy"}},
+     name: "string.quoted.single.groovy",
+     patterns: [{include: "#string-quoted-single-contents"}]},
+   :"string-quoted-single-contents" => 
+    {patterns: [{match: /\\./, name: "constant.character.escape.groovy"}]},
+   :"string-quoted-single-multiline" => 
+    {begin: /'''/,
+     beginCaptures: 
+      {0 => {name: "punctuation.definition.string.begin.groovy"}},
+     end: "'''",
+     endCaptures: {0 => {name: "punctuation.definition.string.end.groovy"}},
+     name: "string.quoted.single.multiline.groovy",
+     patterns: [{include: "#string-quoted-single-contents"}]},
+   strings: 
+    {patterns: 
+      [{include: "#string-quoted-double-multiline"},
+       {include: "#string-quoted-single-multiline"},
+       {include: "#string-quoted-double"},
+       {include: "#string-quoted-single"},
+       {include: "#regexp"}]},
+   structures: 
+    {begin: /\[/,
+     beginCaptures: 
+      {0 => {name: "punctuation.definition.structure.begin.groovy"}},
+     end: "\\]",
+     endCaptures: {0 => {name: "punctuation.definition.structure.end.groovy"}},
+     name: "meta.structure.groovy",
+     patterns: 
+      [{include: "#groovy-code"},
+       {match: /,/, name: "punctuation.definition.separator.groovy"}]},
+   :"support-functions" => 
+    {patterns: 
+      [{match: /(?x)\b(?:sprintf|print(?:f|ln)?)\b/,
+        name: "support.function.print.groovy"},
+       {match: 
+         /(?x)\b(?:shouldFail|fail(?:NotEquals)?|ass(?:ume|ert(?:S(?:cript|ame)|N(?:ot(?:Same|
+	Null)|ull)|Contains|T(?:hat|oString|rue)|Inspect|Equals|False|Length|
+	ArrayEquals)))\b/,
+        name: "support.function.testing.groovy"}]},
+   types: 
+    {patterns: 
+      [{match: /\b(?<_1>def)\b/, name: "storage.type.def.groovy"},
+       {include: "#primitive-types"},
+       {include: "#primitive-arrays"},
+       {include: "#object-types"}]},
+   values: 
+    {patterns: 
+      [{include: "#variables"},
+       {include: "#strings"},
+       {include: "#numbers"},
+       {include: "#constants"},
+       {include: "#types"},
+       {include: "#structures"},
+       {include: "#method-call"}]},
+   variables: 
+    {patterns: 
+      [{match: /\b(?<_1>this|super)\b/, name: "variable.language.groovy"}]}},
+ scopeName: "source.groovy",
+ uuid: "B3A64888-EBBB-4436-8D9E-F1169C5D7613"}