ver 2009.12.14 → 2010.02

data/config/syntax/Java.rb

@@ -0,0 +1,288 @@
+# Encoding: UTF-8
+
+{fileTypes: ["java", "bsh"],
+ foldingStartMarker: /(\{\s*(\/\/.*)?$|^\s*\/\/ \{\{\{)/,
+ foldingStopMarker: /^\s*(\}|\/\/ \}\}\}$)/,
+ keyEquivalent: /^~J/,
+ name: "Java",
+ patterns: 
+  [{captures: 
+     {1 => {name: "keyword.other.package.java"},
+      2 => {name: "storage.modifier.package.java"},
+      3 => {name: "punctuation.terminator.java"}},
+    match: /^\s*(package)\b(?:\s*([^ ;$]+)\s*(;)?)?/,
+    name: "meta.package.java"},
+   {captures: 
+     {1 => {name: "keyword.other.import.java"},
+      2 => {name: "storage.modifier.import.java"},
+      3 => {name: "punctuation.terminator.java"}},
+    match: /^\s*(import)\b(?:\s*([^ ;$]+)\s*(;)?)?/,
+    name: "meta.import.java"},
+   {include: "#code"}],
+ repository: 
+  {:"all-types" => 
+    {patterns: 
+      [{include: "#primitive-arrays"},
+       {include: "#primitive-types"},
+       {include: "#object-types"}]},
+   annotations: 
+    {patterns: 
+      [{begin: /(@[^ (]+)(\()/,
+        beginCaptures: 
+         {1 => {name: "storage.type.annotation.java"},
+          2 => 
+           {name: "punctuation.definition.annotation-arguments.begin.java"}},
+        end: "(\\))",
+        endCaptures: 
+         {1 => {name: "punctuation.definition.annotation-arguments.end.java"}},
+        name: "meta.declaration.annotation.java",
+        patterns: 
+         [{captures: 
+            {1 => {name: "constant.other.key.java"},
+             2 => {name: "keyword.operator.assignment.java"}},
+           match: /(\w*)\s*(=)/},
+          {include: "#code"},
+          {match: /,/, name: "punctuation.seperator.property.java"}]},
+       {match: /@\w*/, name: "storage.type.annotation.java"}]},
+   :"anonymous-classes-and-new" => 
+    {begin: /\bnew\b/,
+     beginCaptures: {0 => {name: "keyword.control.new.java"}},
+     end: "(?<=\\)|\\])(?!\\s*{)|(?<=})|(?=;)",
+     patterns: 
+      [{begin: /(\w+)\s*(?=\[)/,
+        beginCaptures: {1 => {name: "storage.type.java"}},
+        end: "}|(?=;|\\))",
+        patterns: 
+         [{begin: /\[/, end: "\\]", patterns: [{include: "#code"}]},
+          {begin: /{/, end: "(?=})", patterns: [{include: "#code"}]}]},
+       {begin: /(?=\w.*\()/,
+        end: "(?<=\\))",
+        patterns: 
+         [{include: "#object-types"},
+          {begin: /\(/,
+           beginCaptures: {1 => {name: "storage.type.java"}},
+           end: "\\)",
+           patterns: [{include: "#code"}]}]},
+       {begin: /{/,
+        end: "}",
+        name: "meta.inner-class.java",
+        patterns: [{include: "#class-body"}]}]},
+   assertions: 
+    {patterns: 
+      [{begin: /\b(assert)\s/,
+        beginCaptures: {1 => {name: "keyword.control.assert.java"}},
+        end: "$",
+        name: "meta.declaration.assertion.java",
+        patterns: 
+         [{match: /:/,
+           name: "keyword.operator.assert.expression-seperator.java"},
+          {include: "#code"}]}]},
+   class: 
+    {begin: /(?=\w?[\w\s]*(?:class|(?:@)?interface|enum)\s+\w+)/,
+     end: "}",
+     endCaptures: {0 => {name: "punctuation.section.class.end.java"}},
+     name: "meta.class.java",
+     patterns: 
+      [{include: "#storage-modifiers"},
+       {include: "#comments"},
+       {captures: 
+         {1 => {name: "storage.modifier.java"},
+          2 => {name: "entity.name.type.class.java"}},
+        match: /(class|(?:@)?interface|enum)\s+(\w+)/,
+        name: "meta.class.identifier.java"},
+       {begin: /extends/,
+        beginCaptures: {0 => {name: "storage.modifier.extends.java"}},
+        end: "(?={|implements)",
+        name: "meta.definition.class.inherited.classes.java",
+        patterns: 
+         [{include: "#object-types-inherited"}, {include: "#comments"}]},
+       {begin: /(implements)\s/,
+        beginCaptures: {1 => {name: "storage.modifier.implements.java"}},
+        end: "(?=\\s*extends|\\{)",
+        name: "meta.definition.class.implemented.interfaces.java",
+        patterns: 
+         [{include: "#object-types-inherited"}, {include: "#comments"}]},
+       {begin: /{/,
+        end: "(?=})",
+        name: "meta.class.body.java",
+        patterns: [{include: "#class-body"}]}]},
+   :"class-body" => 
+    {patterns: 
+      [{include: "#comments"},
+       {include: "#class"},
+       {include: "#enums"},
+       {include: "#methods"},
+       {include: "#annotations"},
+       {include: "#storage-modifiers"},
+       {include: "#code"}]},
+   code: 
+    {patterns: 
+      [{include: "#comments"},
+       {include: "#class"},
+       {begin: /{/, end: "}", patterns: [{include: "#code"}]},
+       {include: "#assertions"},
+       {include: "#parens"},
+       {include: "#constants-and-special-vars"},
+       {include: "#anonymous-classes-and-new"},
+       {include: "#keywords"},
+       {include: "#storage-modifiers"},
+       {include: "#strings"},
+       {include: "#all-types"}]},
+   comments: 
+    {patterns: 
+      [{captures: {0 => {name: "punctuation.definition.comment.java"}},
+        match: /\/\*\*\//,
+        name: "comment.block.empty.java"},
+       {include: "text.html.javadoc"},
+       {include: "#comments-inline"}]},
+   :"comments-inline" => 
+    {patterns: 
+      [{begin: /\/\*/,
+        captures: {0 => {name: "punctuation.definition.comment.java"}},
+        end: "\\*/",
+        name: "comment.block.java"},
+       {captures: 
+         {1 => {name: "comment.line.double-slash.java"},
+          2 => {name: "punctuation.definition.comment.java"}},
+        match: /\s*((\/\/).*$\n?)/}]},
+   :"constants-and-special-vars" => 
+    {patterns: 
+      [{match: /\b(true|false|null)\b/, name: "constant.language.java"},
+       {match: /\b(this|super)\b/, name: "variable.language.java"},
+       {match: 
+         /\b((0(x|X)[0-9a-fA-F]*)|(([0-9]+\.?[0-9]*)|(\.[0-9]+))((e|E)(\+|-)?[0-9]+)?)([LlFfUuDd]|UL|ul)?\b/,
+        name: "constant.numeric.java"},
+       {captures: {1 => {name: "keyword.operator.dereference.java"}},
+        match: /(\.)?\b([A-Z][A-Z0-9_]+)(?!<|\.class|\s*\w+\s*=)\b/,
+        name: "constant.other.java"}]},
+   enums: 
+    {begin: /^(?=\s*[A-Z0-9_]+\s*({|\(|,))/,
+     end: "(?=;|})",
+     patterns: 
+      [{begin: /\w+/,
+        beginCaptures: {0 => {name: "constant.other.enum.java"}},
+        end: "(?=,|;|})",
+        name: "meta.enum.java",
+        patterns: 
+         [{include: "#parens"},
+          {begin: /{/, end: "}", patterns: [{include: "#class-body"}]}]}]},
+   keywords: 
+    {patterns: 
+      [{match: /\b(try|catch|finally|throw)\b/,
+        name: "keyword.control.catch-exception.java"},
+       {match: /\?|:/, name: "keyword.control.java"},
+       {match: 
+         /\b(return|break|case|continue|default|do|while|for|switch|if|else)\b/,
+        name: "keyword.control.java"},
+       {match: /\b(instanceof)\b/, name: "keyword.operator.java"},
+       {match: /(==|!=|<=|>=|<>|<|>)/,
+        name: "keyword.operator.comparison.java"},
+       {match: /(=)/, name: "keyword.operator.assignment.java"},
+       {match: /(\-\-|\+\+)/,
+        name: "keyword.operator.increment-decrement.java"},
+       {match: /(\-|\+|\*|\/|%)/, name: "keyword.operator.arithmetic.java"},
+       {match: /(!|&&|\|\|)/, name: "keyword.operator.logical.java"},
+       {match: /(?<=\S)\.(?=\S)/, name: "keyword.operator.dereference.java"},
+       {match: /;/, name: "punctuation.terminator.java"}]},
+   methods: 
+    {begin: /(?!new)(?=\w.*\s+)(?=[^=]+\()/,
+     end: "}|(?=;)",
+     name: "meta.method.java",
+     patterns: 
+      [{include: "#storage-modifiers"},
+       {begin: /(\w+)\s*\(/,
+        beginCaptures: {1 => {name: "entity.name.function.java"}},
+        end: "\\)",
+        name: "meta.method.identifier.java",
+        patterns: [{include: "#parameters"}]},
+       {begin: /(?=\w.*\s+\w+\s*\()/,
+        end: "(?=\\w+\\s*\\()",
+        name: "meta.method.return-type.java",
+        patterns: [{include: "#all-types"}]},
+       {include: "#throws"},
+       {begin: /{/,
+        end: "(?=})",
+        name: "meta.method.body.java",
+        patterns: [{include: "#code"}]}]},
+   :"object-types" => 
+    {patterns: 
+      [{begin: /\b((?:[a-z]\w*\.)*[A-Z]+\w*)</,
+        end: ">|[^\\w\\s,\\?<\\[\\]]",
+        name: "storage.type.generic.java",
+        patterns: 
+         [{include: "#object-types"},
+          {begin: /</,
+           comment: "This is just to support <>'s with no actual type prefix",
+           end: ">|[^\\w\\s,\\[\\]<]",
+           name: "storage.type.generic.java"}]},
+       {begin: /\b((?:[a-z]\w*\.)*[A-Z]+\w*)(?=\[)/,
+        end: "(?=[^\\]\\s])",
+        name: "storage.type.object.array.java",
+        patterns: [{begin: /\[/, end: "\\]", patterns: [{include: "#code"}]}]},
+       {captures: {1 => {name: "keyword.operator.dereference.java"}},
+        match: /\b(?:[a-z]\w*(\.))*[A-Z]+\w*\b/,
+        name: "storage.type.java"}]},
+   :"object-types-inherited" => 
+    {patterns: 
+      [{begin: /\b((?:[a-z]\w*\.)*[A-Z]+\w*)</,
+        end: ">|[^\\w\\s,<]",
+        name: "entity.other.inherited-class.java",
+        patterns: 
+         [{include: "#object-types"},
+          {begin: /</,
+           comment: "This is just to support <>'s with no actual type prefix",
+           end: ">|[^\\w\\s,<]",
+           name: "storage.type.generic.java"}]},
+       {captures: {1 => {name: "keyword.operator.dereference.java"}},
+        match: /\b(?:[a-z]\w*(\.))*[A-Z]+\w*/,
+        name: "entity.other.inherited-class.java"}]},
+   parameters: 
+    {patterns: 
+      [{match: /final/, name: "storage.modifier.java"},
+       {include: "#primitive-arrays"},
+       {include: "#primitive-types"},
+       {include: "#object-types"},
+       {match: /\w+/, name: "variable.parameter.java"}]},
+   parens: {begin: /\(/, end: "\\)", patterns: [{include: "#code"}]},
+   :"primitive-arrays" => 
+    {patterns: 
+      [{match: 
+         /\b(?:void|boolean|byte|char|short|int|float|long|double)(\[\])*\b/,
+        name: "storage.type.primitive.array.java"}]},
+   :"primitive-types" => 
+    {patterns: 
+      [{match: /\b(?:void|boolean|byte|char|short|int|float|long|double)\b/,
+        name: "storage.type.primitive.java"}]},
+   :"storage-modifiers" => 
+    {captures: {1 => {name: "storage.modifier.java"}},
+     match: 
+      /\b(public|private|protected|static|final|native|synchronized|abstract|threadsafe|transient)\b/},
+   strings: 
+    {patterns: 
+      [{begin: /"/,
+        beginCaptures: 
+         {0 => {name: "punctuation.definition.string.begin.java"}},
+        end: "\"",
+        endCaptures: {0 => {name: "punctuation.definition.string.end.java"}},
+        name: "string.quoted.double.java",
+        patterns: [{match: /\\./, name: "constant.character.escape.java"}]},
+       {begin: /'/,
+        beginCaptures: 
+         {0 => {name: "punctuation.definition.string.begin.java"}},
+        end: "'",
+        endCaptures: {0 => {name: "punctuation.definition.string.end.java"}},
+        name: "string.quoted.single.java",
+        patterns: [{match: /\\./, name: "constant.character.escape.java"}]}]},
+   throws: 
+    {begin: /throws/,
+     beginCaptures: {0 => {name: "storage.modifier.java"}},
+     end: "(?={|;)",
+     name: "meta.throwables.java",
+     patterns: [{include: "#object-types"}]},
+   values: 
+    {patterns: 
+      [{include: "#strings"},
+       {include: "#object-types"},
+       {include: "#constants-and-special-vars"}]}},
+ scopeName: "source.java",
+ uuid: "2B449DF6-6B1D-11D9-94EC-000D93589AF6"}

data/config/syntax/JavaDoc.rb

@@ -0,0 +1,178 @@
+# Encoding: UTF-8
+
+{fileTypes: [],
+ foldingStartMarker: /\/\*\*/,
+ foldingStopMarker: /\*\*\//,
+ name: "JavaDoc",
+ patterns: 
+  [{begin: /(\/\*\*)\s*$/,
+    beginCaptures: 
+     {1 => {name: "punctuation.definition.comment.begin.javadoc"}},
+    contentName: "text.html",
+    end: "\\*/",
+    endCaptures: {0 => {name: "punctuation.definition.comment.end.javadoc"}},
+    name: "comment.block.documentation.javadoc",
+    patterns: 
+     [{include: "#inline"},
+      {begin: /((\@)param)/,
+       beginCaptures: 
+        {1 => {name: "keyword.other.documentation.param.javadoc"},
+         2 => {name: "punctuation.definition.keyword.javadoc"}},
+       end: "(?=^\\s*\\*?\\s*@|\\*/)",
+       name: "meta.documentation.tag.param.javadoc",
+       patterns: [{include: "#inline"}]},
+      {begin: /((\@)return)/,
+       beginCaptures: 
+        {1 => {name: "keyword.other.documentation.return.javadoc"},
+         2 => {name: "punctuation.definition.keyword.javadoc"}},
+       end: "(?=^\\s*\\*?\\s*@|\\*/)",
+       name: "meta.documentation.tag.return.javadoc",
+       patterns: [{include: "#inline"}]},
+      {begin: /((\@)throws)/,
+       beginCaptures: 
+        {1 => {name: "keyword.other.documentation.throws.javadoc"},
+         2 => {name: "punctuation.definition.keyword.javadoc"}},
+       end: "(?=^\\s*\\*?\\s*@|\\*/)",
+       name: "meta.documentation.tag.throws.javadoc",
+       patterns: [{include: "#inline"}]},
+      {begin: /((\@)exception)/,
+       beginCaptures: 
+        {1 => {name: "keyword.other.documentation.exception.javadoc"},
+         2 => {name: "punctuation.definition.keyword.javadoc"}},
+       end: "(?=^\\s*\\*?\\s*@|\\*/)",
+       name: "meta.documentation.tag.exception.javadoc",
+       patterns: [{include: "#inline"}]},
+      {begin: /((\@)author)/,
+       beginCaptures: 
+        {1 => {name: "keyword.other.documentation.author.javadoc"},
+         2 => {name: "punctuation.definition.keyword.javadoc"}},
+       end: "(?=^\\s*\\*?\\s*@|\\*/)",
+       name: "meta.documentation.tag.author.javadoc",
+       patterns: [{include: "#inline"}]},
+      {begin: /((\@)version)/,
+       beginCaptures: 
+        {1 => {name: "keyword.other.documentation.version.javadoc"},
+         2 => {name: "punctuation.definition.keyword.javadoc"}},
+       end: "(?=^\\s*\\*?\\s*@|\\*/)",
+       name: "meta.documentation.tag.version.javadoc",
+       patterns: [{include: "#inline"}]},
+      {begin: /((\@)see)/,
+       beginCaptures: 
+        {1 => {name: "keyword.other.documentation.see.javadoc"},
+         2 => {name: "punctuation.definition.keyword.javadoc"}},
+       end: "(?=^\\s*\\*?\\s*@|\\*/)",
+       name: "meta.documentation.tag.see.javadoc",
+       patterns: [{include: "#inline"}]},
+      {begin: /((\@)since)/,
+       beginCaptures: 
+        {1 => {name: "keyword.other.documentation.since.javadoc"},
+         2 => {name: "punctuation.definition.keyword.javadoc"}},
+       end: "(?=^\\s*\\*?\\s*@|\\*/)",
+       name: "meta.documentation.tag.since.javadoc",
+       patterns: [{include: "#inline"}]},
+      {begin: /((\@)serial)/,
+       beginCaptures: 
+        {1 => {name: "keyword.other.documentation.serial.javadoc"},
+         2 => {name: "punctuation.definition.keyword.javadoc"}},
+       end: "(?=^\\s*\\*?\\s*@|\\*/)",
+       name: "meta.documentation.tag.serial.javadoc",
+       patterns: [{include: "#inline"}]},
+      {begin: /((\@)serialField)/,
+       beginCaptures: 
+        {1 => {name: "keyword.other.documentation.serialField.javadoc"},
+         2 => {name: "punctuation.definition.keyword.javadoc"}},
+       end: "(?=^\\s*\\*?\\s*@|\\*/)",
+       name: "meta.documentation.tag.serialField.javadoc",
+       patterns: [{include: "#inline"}]},
+      {begin: /((\@)serialData)/,
+       beginCaptures: 
+        {1 => {name: "keyword.other.documentation.serialData.javadoc"},
+         2 => {name: "punctuation.definition.keyword.javadoc"}},
+       end: "(?=^\\s*\\*?\\s*@|\\*/)",
+       name: "meta.documentation.tag.serialData.javadoc",
+       patterns: [{include: "#inline"}]},
+      {begin: /((\@)deprecated)/,
+       beginCaptures: 
+        {1 => {name: "keyword.other.documentation.deprecated.javadoc"},
+         2 => {name: "punctuation.definition.keyword.javadoc"}},
+       end: "(?=^\\s*\\*?\\s*@|\\*/)",
+       name: "meta.documentation.tag.deprecated.javadoc",
+       patterns: [{include: "#inline"}]},
+      {captures: 
+        {1 => {name: "keyword.other.documentation.custom.javadoc"},
+         2 => {name: "punctuation.definition.keyword.javadoc"}},
+       match: /((\@)\S+)\s/}]}],
+ repository: 
+  {inline: 
+    {patterns: 
+      [{include: "#inline-formatting"},
+       {include: "text.html.basic"},
+       {match: 
+         /((https?|s?ftp|ftps|file|smb|afp|nfs|(x-)?man|gopher|txmt):\/\/|mailto:)[-:@a-zA-Z0-9_.~%+\/?=&#]+(?<![.?:])/,
+        name: "markup.underline.link"}]},
+   :"inline-formatting" => 
+    {patterns: 
+      [{begin: /(\{)((\@)code)/,
+        beginCaptures: 
+         {1 => {name: "punctuation.definition.tag.begin.javadoc"},
+          2 => {name: "keyword.other.documentation.directive.code.javadoc"},
+          3 => {name: "punctuation.definition.keyword.javadoc"}},
+        contentName: "markup.raw.code.javadoc",
+        end: "\\}",
+        endCaptures: {0 => {name: "punctuation.definition.tag.end.javadoc"}},
+        name: "meta.tag.template.code.javadoc",
+        patterns: []},
+       {begin: /(\{)((\@)literal)/,
+        beginCaptures: 
+         {1 => {name: "punctuation.definition.tag.begin.javadoc"},
+          2 => {name: "keyword.other.documentation.directive.literal.javadoc"},
+          3 => {name: "punctuation.definition.keyword.javadoc"}},
+        contentName: "markup.raw.literal.javadoc",
+        end: "\\}",
+        endCaptures: {0 => {name: "punctuation.definition.tag.end.javadoc"}},
+        name: "meta.tag.template.literal.javadoc",
+        patterns: []},
+       {captures: 
+         {1 => {name: "punctuation.definition.tag.begin.javadoc"},
+          2 => {name: "keyword.other.documentation.directive.docRoot.javadoc"},
+          3 => {name: "punctuation.definition.keyword.javadoc"},
+          4 => {name: "punctuation.definition.tag.end.javadoc"}},
+        match: /(\{)((\@)docRoot)(\})/,
+        name: "meta.tag.template.docRoot.javadoc"},
+       {captures: 
+         {1 => {name: "punctuation.definition.tag.begin.javadoc"},
+          2 => 
+           {name: "keyword.other.documentation.directive.inheritDoc.javadoc"},
+          3 => {name: "punctuation.definition.keyword.javadoc"},
+          4 => {name: "punctuation.definition.tag.end.javadoc"}},
+        match: /(\{)((\@)inheritDoc)(\})/,
+        name: "meta.tag.template.inheritDoc.javadoc"},
+       {captures: 
+         {1 => {name: "punctuation.definition.tag.begin.javadoc"},
+          2 => {name: "keyword.other.documentation.directive.link.javadoc"},
+          3 => {name: "punctuation.definition.keyword.javadoc"},
+          4 => {name: "markup.underline.link.javadoc"},
+          5 => {name: "string.other.link.title.javadoc"},
+          6 => {name: "punctuation.definition.tag.end.javadoc"}},
+        match: /(\{)((\@)link)(?:\s+(\S+?))?(?:\s+(.+?))?\s*(\})/,
+        name: "meta.tag.template.link.javadoc"},
+       {captures: 
+         {1 => {name: "punctuation.definition.tag.begin.javadoc"},
+          2 => 
+           {name: "keyword.other.documentation.directive.linkplain.javadoc"},
+          3 => {name: "punctuation.definition.keyword.javadoc"},
+          4 => {name: "markup.underline.linkplain.javadoc"},
+          5 => {name: "string.other.link.title.javadoc"},
+          6 => {name: "punctuation.definition.tag.end.javadoc"}},
+        match: /(\{)((\@)linkplain)(?:\s+(\S+?))?(?:\s+(.+?))?\s*(\})/,
+        name: "meta.tag.template.linkplain.javadoc"},
+       {captures: 
+         {1 => {name: "punctuation.definition.tag.begin.javadoc"},
+          2 => {name: "keyword.other.documentation.directive.value.javadoc"},
+          3 => {name: "punctuation.definition.keyword.javadoc"},
+          4 => {name: "variable.other.javadoc"},
+          5 => {name: "punctuation.definition.tag.end.javadoc"}},
+        match: /(\{)((\@)value)\s*(\S+?)?\s*(\})/,
+        name: "meta.tag.template.value.javadoc"}]}},
+ scopeName: "text.html.javadoc",
+ uuid: "64BB98A4-59D4-474E-9091-C1E1D04BDD03"}