ver 2009.12.14 → 2010.02

data/config/syntax/Regular Expressions (Oniguruma).rb

@@ -0,0 +1,78 @@
+# Encoding: UTF-8
+
+{comment: 
+  "Matches Oniguruma's Ruby regexp syntax (TextMate uses Oniguruma in Ruby mode).",
+ fileTypes: ["re"],
+ foldingStartMarker: /(\/\*|\{|\()/,
+ foldingStopMarker: /(\*\/|\}|\))/,
+ name: "Regular Expressions (Oniguruma)",
+ patterns: 
+  [{match: /\\[bBAZzG]|\^|\$/, name: "keyword.control.anchor.regexp"},
+   {match: /\\([0-7]{3}|\\x(\h\h|\{\h{,8}\}))/,
+    name: "constant.character.numeric.regexp"},
+   {match: /\\[1-9]\d*/, name: "keyword.other.back-reference.regexp"},
+   {captures: 
+     {1 => {name: "keyword.other.back-reference.named.regexp"},
+      2 => {name: "entity.name.section.back-reference"},
+      3 => {name: "keyword.other.back-reference.named.regexp"}},
+    match: /(\\k\<)([a-z]\w*)(\>)/,
+    name: "keyword.other.back-reference.named.regexp"},
+   {match: 
+     /\[\:(\^)?(alnum|alpha|ascii|blank|cntrl|x?digit|graph|lower|print|punct|space|upper)\]/,
+    name: "constant.other.character-class.posix.regexp"},
+   {match: /[?+*][?+]?|\{(\d+,\d+|\d+,|,\d+|\d+)\}\??/,
+    name: "keyword.operator.quantifier.regexp"},
+   {match: /\|/, name: "keyword.operator.or.regexp"},
+   {begin: /\(\?\#/, end: "\\)", name: "comment.block.regexp"},
+   {comment: 
+     "We are restrictive in what we allow to go after the comment character to avoid false positives, since the availability of comments depend on regexp flags.",
+    match: /(?<=^|\s)#\s[[a-zA-Z0-9,. \t?!-:][^\x00-\x7F]]*$/,
+    name: "comment.line.number-sign.regexp"},
+   {match: /\(\?[imx-]+\)/, name: "keyword.other.option-toggle.regexp"},
+   {begin: /(\()((\?=)|(\?!)|(\?<=)|(\?<!))/,
+    beginCaptures: 
+     {1 => {name: "punctuation.definition.group.regexp"},
+      3 => {name: "meta.assertion.look-ahead.regexp"},
+      4 => {name: "meta.assertion.negative-look-ahead.regexp"},
+      5 => {name: "meta.assertion.look-behind.regexp"},
+      6 => {name: "meta.assertion.negative-look-behind.regexp"}},
+    end: "(\\))",
+    endCaptures: {1 => {name: "punctuation.definition.group.regexp"}},
+    name: "meta.group.assertion.regexp",
+    patterns: [{include: "$self"}]},
+   {begin: /(\()((\?(>|[imx-]*:))|(\?<)([a-z]\w*)(>))?/,
+    beginCaptures: 
+     {1 => {name: "punctuation.definition.group.regexp"},
+      3 => {name: "keyword.other.group-options.regexp"},
+      5 => {name: "keyword.other.group-options.regexp"},
+      6 => {name: "entity.name.section.group.regexp"},
+      7 => {name: "keyword.other.group-options.regexp"}},
+    end: "(\\))",
+    endCaptures: {1 => {name: "punctuation.definition.group.regexp"}},
+    name: "meta.group.regexp",
+    patterns: [{include: "$self"}]},
+   {include: "#character-class"}],
+ repository: 
+  {:"character-class" => 
+    {patterns: 
+      [{match: /\\[wWsSdDhH]|\./,
+        name: "constant.character.character-class.regexp"},
+       {match: /\\./, name: "constant.character.escape.backslash.regexp"},
+       {begin: /(\[)(\^)?/,
+        beginCaptures: 
+         {1 => {name: "punctuation.definition.character-class.regexp"},
+          2 => {name: "keyword.operator.negation.regexp"}},
+        end: "(\\])",
+        endCaptures: 
+         {1 => {name: "punctuation.definition.character-class.regexp"}},
+        name: "constant.other.character-class.set.regexp",
+        patterns: 
+         [{include: "#character-class"},
+          {captures: 
+            {2 => {name: "constant.character.escape.backslash.regexp"},
+             4 => {name: "constant.character.escape.backslash.regexp"}},
+           match: /(.|(\\.))\-([^\]]|(\\.))/,
+           name: "constant.other.character-class.range.regexp"},
+          {match: /&&/, name: "keyword.operator.intersection.regexp"}]}]}},
+ scopeName: "source.regexp.oniguruma",
+ uuid: "D609BF3F-BEDB-41AE-BA6F-903CC77A7BB3"}

data/config/syntax/Regular Expressions (Python).rb

@@ -0,0 +1,78 @@
+# Encoding: UTF-8
+
+{comment: "Matches Python's regular expression syntax.",
+ fileTypes: ["re"],
+ foldingStartMarker: /(\/\*|\{|\()/,
+ foldingStopMarker: /(\*\/|\}|\))/,
+ name: "Regular Expressions (Python)",
+ patterns: 
+  [{match: /\\[bBAZzG]|\^|\$/, name: "keyword.control.anchor.regexp"},
+   {match: /\\[1-9][0-9]?/, name: "keyword.other.back-reference.regexp"},
+   {match: /[?+*][?+]?|\{(\d+,\d+|\d+,|,\d+|\d+)\}\??/,
+    name: "keyword.operator.quantifier.regexp"},
+   {match: /\|/, name: "keyword.operator.or.regexp"},
+   {begin: /\(\?\#/, end: "\\)", name: "comment.block.regexp"},
+   {comment: 
+     "We are restrictive in what we allow to go after the comment character to avoid false positives, since the availability of comments depend on regexp flags.",
+    match: /(?<=^|\s)#\s[[a-zA-Z0-9,. \t?!-:][^\x00-\x7F]]*$/,
+    name: "comment.line.number-sign.regexp"},
+   {match: /\(\?[iLmsux]+\)/, name: "keyword.other.option-toggle.regexp"},
+   {match: /(\()(\?P=([a-zA-Z_][a-zA-Z_0-9]*\w*))(\))/,
+    name: "keyword.other.back-reference.named.regexp"},
+   {begin: /(\()((\?=)|(\?!)|(\?<=)|(\?<!))/,
+    beginCaptures: 
+     {1 => {name: "punctuation.definition.group.regexp"},
+      2 => {name: "punctuation.definition.group.assertion.regexp"},
+      3 => {name: "meta.assertion.look-ahead.regexp"},
+      4 => {name: "meta.assertion.negative-look-ahead.regexp"},
+      5 => {name: "meta.assertion.look-behind.regexp"},
+      6 => {name: "meta.assertion.negative-look-behind.regexp"}},
+    end: "(\\))",
+    endCaptures: {1 => {name: "punctuation.definition.group.regexp"}},
+    name: "meta.group.assertion.regexp",
+    patterns: [{include: "$self"}]},
+   {begin: /(\()(\?\(([1-9][0-9]?|[a-zA-Z_][a-zA-Z_0-9]*)\))/,
+    beginCaptures: 
+     {1 => {name: "punctuation.definition.group.regexp"},
+      2 => {name: "punctuation.definition.group.assertion.conditional.regexp"},
+      3 => {name: "entity.name.section.back-reference.regexp"}},
+    comment: 
+     "we can make this more sophisticated to match the | character that separates yes-pattern from no-pattern, but it's not really necessary.",
+    end: "(\\))",
+    name: "meta.group.assertion.conditional.regexp",
+    patterns: [{include: "$self"}]},
+   {begin: /(\()((\?P<)([a-z]\w*)(>)|(\?:))?/,
+    beginCaptures: 
+     {1 => {name: "punctuation.definition.group.regexp"},
+      3 => {name: "punctuation.definition.group.capture.regexp"},
+      4 => {name: "entity.name.section.group.regexp"},
+      5 => {name: "punctuation.definition.group.capture.regexp"},
+      6 => {name: "punctuation.definition.group.no-capture.regexp"}},
+    end: "(\\))",
+    endCaptures: {1 => {name: "punctuation.definition.group.regexp"}},
+    name: "meta.group.regexp",
+    patterns: [{include: "$self"}]},
+   {include: "#character-class"}],
+ repository: 
+  {:"character-class" => 
+    {patterns: 
+      [{match: /\\[wWsSdDhH]|\./,
+        name: "constant.character.character-class.regexp"},
+       {match: /\\./, name: "constant.character.escape.backslash.regexp"},
+       {begin: /(\[)(\^)?/,
+        beginCaptures: 
+         {1 => {name: "punctuation.definition.character-class.regexp"},
+          2 => {name: "keyword.operator.negation.regexp"}},
+        end: "(\\])",
+        endCaptures: 
+         {1 => {name: "punctuation.definition.character-class.regexp"}},
+        name: "constant.other.character-class.set.regexp",
+        patterns: 
+         [{include: "#character-class"},
+          {captures: 
+            {2 => {name: "constant.character.escape.backslash.regexp"},
+             4 => {name: "constant.character.escape.backslash.regexp"}},
+           match: /((\\.)|.)\-((\\.)|[^\]])/,
+           name: "constant.other.character-class.range.regexp"}]}]}},
+ scopeName: "source.regexp.python",
+ uuid: "DD867ABF-1EC6-415D-B047-687F550A1D51"}

data/config/syntax/Release Notes.rb

@@ -0,0 +1,38 @@
+# Encoding: UTF-8
+
+{fileTypes: ["tmReleaseNotes"],
+ name: "Release Notes",
+ patterns: 
+  [{captures: 
+     {1 => {name: "punctuation.definition.separator.release-notes"},
+      2 => {name: "meta.toc-list.release-notes"},
+      3 => {name: "punctuation.definition.separator.release-notes"}},
+    match: /^(\[)(?:[\d-]+: )?(REVISION (\d+|v[\d.b]+))(\])$\n/,
+    name: "meta.separator.release-notes"},
+   {begin: /^([ \t]*)(?=\S)/,
+    contentName: "meta.paragraph.release-notes",
+    end: "^(?!\\1(?=\\S))",
+    patterns: 
+     [{match: /(https?|ftp|mailto):\S+?(?=[)>,.':;"]*(\s|$)|$)/,
+       name: "markup.underline.link.release-notes"},
+      {captures: 
+        {1 => {name: "keyword.other.release-notes"},
+         2 => {name: "punctuation.definition.keyword.release-notes"},
+         3 => {name: "punctuation.definition.keyword.release-notes"},
+         4 => {name: "constant.other.bundle-name.release-notes"}},
+       match: 
+        /((\[)(?:NEW|FIXED|CHANGED|REMOVED|INFO)(\])) (?:(.+? bundle):)?/},
+      {captures: 
+        {1 => {name: "storage.type.ticket.release-notes"},
+         2 => {name: "constant.numeric.ticket.release-notes"}},
+       match: /([Tt]icket) ([0-9A-F]{8})\b/,
+       name: "meta.ticket.release-notes"},
+      {comment: 
+        "I do not want spell checking for CamelCase words. Since this is generally when quoting various API’s, I have deliberately used A-Z and a-z (ASCII) -- Allan",
+       match: /\b[A-Z]*[a-z]+[A-Z]\w*\b/,
+       name: "meta.word.camel-case.release-notes"},
+      {captures: {1 => {name: "constant.other.committer-name.release-notes"}},
+       match: 
+        /\((G(erd Knops|a(vin Kistner|rrett J. Woodworth)|ra(nt Hollingworth|eme Rocher))|R(yan McCuaig|ich Barton|o(ss Harmes|ger Braunstein|b(ert Rainthorpe| (Rix|Bevan))))|M(i(cha(il Pishchagin|el Sheets)|tch Chapman|etek Bąk|k(e Mellor|ael Säker))|a(t(s Persson|t(hew Gilbert|eo Spinelli| Pelletier))|r(tin Ström|k Grimes)|x Williams))|B(ill Duenskie|ob Fleck|en(oit Gagnon|jamin Jackson| Perry)|arrett Clark|r(ian (Donovan|Lalor)|ett Terpstra|ad (Miller|Choate)))|H(enrik Nyh|adley Wickham)|S(t(ephen Skubik-Peplaski|éphane Payrard|anley Rost)|imon (Gregory|Strandgaard)|u(ne Foldager|dara Williams)|ebastian Gräßl|am DeVore)|Nathan Youngman|C(h(a(ndler McWilliams|rilaos Skiadas)|ris(topher Forsythe| (Thomas|Jenkins)))|iarán Walsh)|T(homas Aylott|o(rsten Becker|m Lazar|bias Luetke)|akaaki Kato|roy Mcilvena)|Ian (Joyner|White)|Ollivier Robert|D(om(inique Peretti|enico Carbotta)|uane Johnson|a(n(iel Harple| Kelley)|vid (Glasser|Bonnet|Hansson|Powers|Wikler))|rew Colthorp)|J(iun Wei Chia|o(shua Emmons|nathan (Ragan-Kelley|Chaffer)|e Maller|achim Mårtensson)|ustin French|eroen van der Ham|a(cob Rus|y Soffian|kub Nešetřil|m(is Buck|es (Edward Gray II|A. Baker))))|Paul(o Jorge Lopes de Moura| Bissex)|Eric Hsu|K(umar McMillan|evin Ballard)|F(ergus Bremner|abien POTENCIER|lorent Pillet|r(édéric Ballériaux|ank Brault))|Wil(son Miner|liam (D. Neumann|Prater))|A(n(thony Underwood|d(y Herbert|ers Thid|rew Henson))|dam Sanderson|urelio Marinho Jargas|parajita Fishman|l(e( Muñoz|xand(er John Ross|re Girard))|an Schussman|lan Odgaard)|mro Nasr))\)$/}]}],
+ scopeName: "text.plain.release-notes",
+ uuid: "8926CAFE-1CF3-4CF9-A056-4FF90F596E9A"}

data/config/syntax/Remind.rb

@@ -0,0 +1,179 @@
+# Encoding: UTF-8
+
+{fileTypes: ["defs.rem", "REM*.txt", ".reminders"],
+ firstLineMatch: "^REM*",
+ name: "Remind",
+ patterns: 
+  [{captures: {1 => {name: "punctuation.definition.comment.remind"}},
+    match: /[ ]*(#).*\n?/,
+    name: "comment.line.number-sign.remind"},
+   {captures: {1 => {name: "punctuation.definition.comment.remind"}},
+    match: /[ ]*(;).*\n?/,
+    name: "comment.line.semicolon.remind"},
+   {captures: {0 => {name: "keyword.control.single.command.remind"}},
+    match: /\b(?i:(?:RUN\s+(ON|OFF))|(PUSH|CLEAR|POP)-OMIT-CONTEXT)\b/,
+    name: "meta.single.command.remind"},
+   {begin: /\b(?i:(SET))\s+(\$?\w+)\s+/,
+    beginCaptures: 
+     {1 => {name: "keyword.control.set.setline.remind"},
+      2 => {name: "variable.other.setline.remind"}},
+    end: "(?=#|\\n|\\z)",
+    name: "meta.setline.remind",
+    patterns: [{include: "#expression"}]},
+   {begin: /\b(?i:(FSET))\s+(\w+(\())(\w+)?(?:,(\w+))*(\))/,
+    beginCaptures: 
+     {1 => {name: "keyword.control.fset.fsetline.remind"},
+      2 => {name: "entity.name.function.fsetline.remind"},
+      3 => {name: "punctuation.definition.arguments.remind"},
+      4 => {name: "variable.parameter.fsetline.remind"},
+      5 => {name: "variable.parameter.fsetline.remind"},
+      6 => {name: "punctuation.definition.arguments.remind"}},
+    end: "(?=#|\\n|\\z)",
+    name: "meta.fsetline.remind",
+    patterns: [{include: "#expression"}]},
+   {begin: /\b(?i:(UNSET))\b/,
+    beginCaptures: {1 => {name: "keyword.control.set.unsetline.remind"}},
+    end: "(?=#|\\n|\\z)",
+    name: "meta.unsetline.remind",
+    patterns: [{match: /\b\w+\b/, name: "variable.other.unsetline.remind"}]},
+   {begin: /\b(?i:(IF))\b/,
+    captures: {1 => {name: "keyword.control.if.remind"}},
+    end: "(?=#|\\n|\\z)",
+    name: "meta.if.remind",
+    patterns: [{include: "#expression"}]},
+   {begin: /\b(?i:(IFTRIG))\b/,
+    captures: {1 => {name: "keyword.control.iftrig.remind"}},
+    end: "(?=#|\\n|\\z)",
+    name: "meta.iftrig.remind",
+    patterns: [{include: "#trigger"}]},
+   {match: /\b(?i:(ELSE|ENDIF))\s*(?=#|\n|\z)/,
+    name: "keyword.control.else-or-endif.remind"},
+   {begin: /\b(?i:INCLUDE)\b/,
+    beginCaptures: {0 => {name: "keyword.control.include.commandline.remind"}},
+    end: "(?=#|\\n|\\z)",
+    name: "meta.includeline.remind"},
+   {begin: /\b(?i:REM|OMIT|BANNER)\b/,
+    beginCaptures: {0 => {name: "keyword.control.command.commandline.remind"}},
+    end: "(%?[ \\t]*)(?=(#|\\n|\\z))",
+    endCaptures: {0 => {name: "keyword.control.endline.commandline.remind"}},
+    name: "meta.commandline.remind",
+    patterns: 
+     [{match: /\b(?i:SCHED|WARN|SCANFROM|SCAN|UNTIL)\b/,
+       name: "keyword.control.expiry.commandline.remind"},
+      {begin: /\b(?i:SATISFY)\b/,
+       beginCaptures: 
+        {0 => {name: "keyword.control.satisfy.commandline.remind"}},
+       end: "(?=(#|\\n|\\z))",
+       name: "meta.satisfy.remind",
+       patterns: [{include: "#expression"}]},
+      {include: "#trigger"},
+      {include: "#message-body"},
+      {include: "#bracketed-expression"},
+      {include: "#message"}]},
+   {include: "#bracketed-expression"},
+   {include: "#message"}],
+ repository: 
+  {:"bracketed-expression" => 
+    {begin: /\[/,
+     captures: {0 => {name: "punctuation.section.scope.remind"}},
+     end: "\\]",
+     patterns: [{include: "#expression"}]},
+   :"date-item" => 
+    {patterns: 
+      [{match: 
+         /\b(?i:January|Jan|February|Feb|March|Mar|April|Apr|May|June|Jun|July|Jul|August|Aug|September|Sep|October|Oct|November|Nov|December|Dec)\b/,
+        name: "support.constant.month.dateitem.remind"},
+       {match: 
+         /\b(?i:Monday|Mon|Tuesday|Tue|Wednesday|Wed|Thursday|Thu|Friday|Fri|Saturday|Sat|Sunday|Sun)\b/,
+        name: "support.constant.weekday.dateitem.remind"},
+       {match: /\b(?:\d{1,2})\b/,
+        name: "support.constant.day.dateitem.remind"},
+       {match: /\b(?:\d{4})\b/,
+        name: "support.constant.year.dateitem.remind"}]},
+   expression: 
+    {patterns: 
+      [{begin: /\(/,
+        captures: {0 => {name: "punctuation.section.scope.remind"}},
+        end: "\\)",
+        patterns: [{include: "#expression"}]},
+       {match: /-|\*|\/|%|\+|-|[!<>=]=?|&&|\|\|/,
+        name: "keyword.operator.remind"},
+       {begin: /"/,
+        beginCaptures: 
+         {0 => {name: "punctuation.definition.string.begin.remind"}},
+        end: "\"",
+        endCaptures: {0 => {name: "punctuation.definition.string.end.remind"}},
+        name: "string.quoted.double.remind",
+        patterns: [{match: /\\./, name: "constant.character.escape.remind"}]},
+       {match: /'\d{4}([\-\/])\d{1,2}\1\d{1,2}'/,
+        name: "constant.other.date.remind"},
+       {match: /\d{1,2}[:.]\d{2}/, name: "constant.other.time.remind"},
+       {match: /\d+/, name: "constant.numeric.integer.remind"},
+       {match: 
+         /\$(?:CalcUTC|CalMode|Daemon|DefaultPrio|DontFork|DontTrigAts|DontQueue|EndSent|EndSentIg|FirstIndent|FoldYear|FormWidth|HushMode|IgnoreOnce|InfDelta|LatDeg|LatMin|LatSec|Location|LongDeg|LongMin|LongSec|MaxSatIter|MinsFromUTC|NextMode|NumQueued|NumTrig|PrefixLineNo|PSCal|RunOff|SimpleCal|SortByDate|SortByPrio|SortByTime|SubsIndent)\b/,
+        name: "variable.language.system.remind"},
+       {begin: 
+         /\b(?:abs|access|args|asc|baseyr|char|choose|coerce|date|dawn|day|daysinmon|defined|dosubst|dusk|easterdate|filedate|filedir|filename|getenv|hour|iif|index|isdst|isleap|isomitted|hebdate|hebday|hebmon|hebyear|language|lower|max|min|minsfromutc|minute|min|monnum|moondate|moontime|moonphase|now|ord|ostype|plural|psmoon|psshade|realnow|realtoday|sgn|shell|strlen|substr|sunrise|sunset|time|today|trigdate|trigger|trigtime|trigvalid|typeof|upper|value|version|wkday|wkdaynum|year)\(/,
+        captures: {0 => {name: "support.function.builtin.remind"}},
+        end: "\\)",
+        name: "meta.function.builtin.remind",
+        patterns: [{include: "#expression"}]},
+       {begin: /\b(\w+)(\()/,
+        beginCaptures: 
+         {1 => {name: "entity.name.function.remind"},
+          2 => {name: "punctuation.definition.arguments.remind"}},
+        end: "(\\))",
+        endCaptures: {1 => {name: "punctuation.definition.arguments.remind"}},
+        name: "meta.function.user.remind",
+        patterns: [{include: "#expression"}]},
+       {match: /\b\w+\b/, name: "variable.parameter.user.remind"}]},
+   message: 
+    {begin: /\b(?i:MSG|MSF|RUN|CAL|SPECIAL|PS|PSFILE)\b\s*/,
+     beginCaptures: 
+      {0 => {name: "keyword.control.message.commandline.remind"}},
+     end: "(%?[ \\t]*)(?=\\n|\\z)",
+     endCaptures: {0 => {name: "keyword.control.endline.commandline.remind"}},
+     patterns: [{include: "#message-body"}]},
+   :"message-body" => 
+    {patterns: 
+      [{captures: {1 => {name: "punctuation.definition.constant.remind"}},
+        match: /(%)[a-zA-Z0-9_!@#]/,
+        name: "constant.other.placeholder.remind"},
+       {begin: /%"/,
+        beginCaptures: 
+         {0 => {name: "punctuation.definition.string.begin.remind"}},
+        end: "%\"",
+        endCaptures: {0 => {name: "punctuation.definition.string.end.remind"}},
+        name: "string.quoted.double.remind"},
+       {include: "#bracketed-expression"}]},
+   trigger: 
+    {patterns: 
+      [{captures: 
+         {1 => {name: "keyword.other.attime.trigger.remind"},
+          2 => {name: "constant.other.time.trigger.remind"},
+          3 => {name: "variable.other.component.trigger.remind"},
+          4 => {name: "variable.other.comp.trigger.remind"}},
+        match: 
+         /\b(?i:(AT))\s+(\d{1,2}[:.]\d{2})(?:\s+(\+{1,2}\d+))?(?:\s+(\*\d+))?(?=\s)/,
+        name: "meta.attime.trigger.remind"},
+       {captures: 
+         {1 => {name: "keyword.other.duration.trigger.remind"},
+          2 => {name: "constant.other.time.trigger.remind"}},
+        match: /\b(?i:(DURATION))\s+(\d{1,2}[:.]\d{2})(?=\s)/,
+        name: "meta.duration.trigger.remind"},
+       {match: /\b(?i:OMIT)\b/,
+        name: "keyword.control.command.trigger.remind"},
+       {match: /\b(?i:ONCE|SKIP|BEFORE|AFTER)\b/,
+        name: "keyword.control.move-reminder.trigger.remind"},
+       {captures: {1 => {name: "punctuation.definition.variable.remind"}},
+        match: /(\+{1,2})\d+/,
+        name: "variable.other.component.delta.trigger.remind"},
+       {captures: {1 => {name: "punctuation.definition.variable.remind"}},
+        match: /(\-{1,2})\d+/,
+        name: "variable.other.component.back.trigger.remind"},
+       {captures: {1 => {name: "punctuation.definition.variable.remind"}},
+        match: /(\*)\d+/,
+        name: "variable.other.component.repeat.trigger.remind"},
+       {include: "#date-item"}]}},
+ scopeName: "source.remind",
+ uuid: "8D255A1E-9CBC-4B22-8AAD-F8536C276727"}

data/config/syntax/Rez.rb

@@ -0,0 +1,61 @@
+# Encoding: UTF-8
+
+{comment: 
+  "Rez. Legacy Mac OS source code frequently contains Rez files. – chris@cjack.com",
+ fileTypes: ["r"],
+ foldingStartMarker: /(\/\*\*|\{\s*$)/,
+ foldingStopMarker: /(\*\*\/|^\s*\})/,
+ keyEquivalent: "^~R",
+ name: "Rez",
+ patterns: 
+  [{begin: /\/\*/,
+    captures: {0 => {name: "punctuation.definition.comment.rez"}},
+    end: "\\*/",
+    name: "comment.block.rez"},
+   {captures: {1 => {name: "punctuation.definition.comment.rez"}},
+    match: /(\/\/).*$\n?/,
+    name: "comment.line.double-slash.rez"},
+   {comment: 
+     "Note that Xcode gets case sensitivity wrong (last checked Xcode 2.0). I'm not sure built-in functions are case-insensitive, though, so we might too.",
+    match: /\b(?i:(change|data|delete|include|read|resource|type))\b/,
+    name: "keyword.control.rez"},
+   {match: 
+     /\b(?i:(align|array|binary|bit|bitstring|boolean|byte|case|char|cstring|decimal|enum|fill|hex|integer|key|literal|long|longint|nibble|octal|point|pstring|rect|string|switch|unsigned|wide|word|wstring))\b/,
+    name: "storage.type.rez"},
+   {match: /\b(?i:(appheap|locked|nonpurgeable|purgeable|sysheap|unlocked))\b/,
+    name: "keyword.other.attributes.rez"},
+   {captures: {1 => {name: "punctuation.definition.function.rez"}},
+    match: 
+     /(\$\$)(?i:(ArrayIndex|Attributes|BitField|Byte|CountOf|Date|Day|Format|Hour|ID|Long|Minute|Month|Name|PackedSize|Read|Resource|ResourceSize|Second|Shell|Time|Type|Version|Weekday|Word|Year))/,
+    name: "support.function.built-in.rez"},
+   {match: 
+     /\b(((0(x|X|B)|\$)[0-9a-fA-F]*)|(([0-9]+\.?[0-9]*)|(\.[0-9]+))((e|E)(\+|-)?[0-9]+)?)\b/,
+    name: "constant.numeric.rez"},
+   {begin: /"/,
+    beginCaptures: {0 => {name: "punctuation.definition.string.begin.rez"}},
+    end: "\"",
+    endCaptures: {0 => {name: "punctuation.definition.string.end.rez"}},
+    name: "string.quoted.double.rez",
+    patterns: [{include: "#escaped_char"}]},
+   {begin: /'/,
+    beginCaptures: {0 => {name: "punctuation.definition.string.begin.rez"}},
+    end: "'",
+    endCaptures: {0 => {name: "punctuation.definition.string.end.rez"}},
+    name: "string.quoted.single.rez",
+    patterns: [{include: "#escaped_char"}]},
+   {begin: /\$"/,
+    beginCaptures: {0 => {name: "punctuation.definition.string.begin.rez"}},
+    end: "\"",
+    endCaptures: {0 => {name: "punctuation.definition.string.end.rez"}},
+    name: "string.quoted.other.hex.rez",
+    patterns: [{include: "#escaped_char"}]},
+   {captures: 
+     {1 => {name: "punctuation.definition.preprocessor.rez"},
+      2 => {name: "keyword.control.import.rez"}},
+    match: 
+     /^\s*(#)\s*(define|defined|else|elif|endif|if|ifdef|ifndef|include|line|printf|undef)\b/,
+    name: "meta.preprocessor.rez"}],
+ repository: 
+  {escaped_char: {match: /\\./, name: "constant.character.escape.rez"}},
+ scopeName: "source.rez",
+ uuid: "F3EB29E9-8DB7-4052-9D48-5CDD2491D8D3"}

data/config/syntax/Ruby Haml.rb

@@ -0,0 +1,97 @@
+# Encoding: UTF-8
+
+{fileTypes: ["haml", "sass"],
+ foldingStartMarker: /^\s*([-%#\:\.\w\=].*)\s$/,
+ foldingStopMarker: /^\s*$/,
+ keyEquivalent: "^~H",
+ name: "Ruby Haml",
+ patterns: 
+  [{begin: /^\s*==/,
+    contentName: "string.quoted.double.ruby",
+    end: "$\\n?",
+    patterns: [{include: "#interpolated_ruby"}]},
+   {captures: {1 => {name: "punctuation.definition.prolog.haml"}},
+    match: /^(!!!)($|\s.*)/,
+    name: "meta.prolog.haml"},
+   {captures: {1 => {name: "punctuation.section.comment.haml"}},
+    match: /^ *(\/)\s*\S.*$\n?/,
+    name: "comment.line.slash.haml"},
+   {begin: /^( *)(\/)\s*$/,
+    beginCaptures: {2 => {name: "punctuation.section.comment.haml"}},
+    end: "^(?!\\1  )",
+    name: "comment.block.haml",
+    patterns: [{include: "text.haml"}]},
+   {begin: /^\s*(?:((%)([\w:]+))|(?=\.|#))/,
+    captures: 
+     {1 => {name: "meta.tag.haml"},
+      2 => {name: "punctuation.definition.tag.haml"},
+      3 => {name: "entity.name.tag.haml"}},
+    end: "$|(?!\\.|#|\\{|\\[|=|-|~|/)",
+    patterns: 
+     [{begin: /==/,
+       contentName: "string.quoted.double.ruby",
+       end: "$\\n?",
+       patterns: [{include: "#interpolated_ruby"}]},
+      {match: /\.[\w-]+/, name: "entity.name.tag.class.haml"},
+      {match: /#[\w-]+/, name: "entity.name.tag.id.haml"},
+      {begin: /\{(?=.*\}|.*\|\s*$)/,
+       end: "\\}|$|^(?!.*\\|\\s*$)",
+       name: "meta.section.attributes.haml",
+       patterns: [{include: "source.ruby.rails"}, {include: "#continuation"}]},
+      {begin: /\[(?=.*\]|.*\|\s*$)/,
+       end: "\\]|$|^(?!.*\\|\\s*$)",
+       name: "meta.section.object.haml",
+       patterns: [{include: "source.ruby.rails"}, {include: "#continuation"}]},
+      {include: "#rubyline"},
+      {match: /\//, name: "punctuation.terminator.tag.haml"}]},
+   {captures: {1 => {name: "meta.escape.haml"}}, match: /^\s*(\\.)/},
+   {begin: /^\s*(?==|-|~)/, end: "$", patterns: [{include: "#rubyline"}]}],
+ repository: 
+  {continuation: 
+    {captures: {1 => {name: "punctuation.separator.continuation.haml"}},
+     match: /(\|)\s*\n/},
+   interpolated_ruby: 
+    {patterns: 
+      [{captures: 
+         {0 => {name: "punctuation.section.embedded.ruby"},
+          1 => {name: "source.ruby.embedded.source.empty"}},
+        match: /#\{(\})/,
+        name: "source.ruby.embedded.source"},
+       {begin: /#\{/,
+        captures: {0 => {name: "punctuation.section.embedded.ruby"}},
+        end: "(\\})",
+        name: "source.ruby.embedded.source",
+        patterns: 
+         [{include: "#nest_curly_and_self"}, {include: "source.ruby"}]},
+       {captures: {1 => {name: "punctuation.definition.variable.ruby"}},
+        match: /(\#@)[a-zA-Z_]\w*/,
+        name: "variable.other.readwrite.instance.ruby"},
+       {captures: {1 => {name: "punctuation.definition.variable.ruby"}},
+        match: /(\#@@)[a-zA-Z_]\w*/,
+        name: "variable.other.readwrite.class.ruby"},
+       {captures: {1 => {name: "punctuation.definition.variable.ruby"}},
+        match: /(#\$)[a-zA-Z_]\w*/,
+        name: "variable.other.readwrite.global.ruby"}]},
+   nest_curly_and_self: 
+    {patterns: 
+      [{begin: /\{/,
+        captures: {0 => {name: "punctuation.section.scope.ruby"}},
+        end: "\\}",
+        patterns: [{include: "#nest_curly_and_self"}]},
+       {include: "source.ruby"}]},
+   rubyline: 
+    {begin: /=|-|~/,
+     contentName: "source.ruby.embedded.haml",
+     end: "((do|\\{)( \\|[^|]+\\|)?)$|$|^(?!.*\\|\\s*$)",
+     endCaptures: 
+      {1 => {name: "source.ruby.embedded.html"},
+       2 => {name: "keyword.control.ruby.start-block"}},
+     name: "meta.line.ruby.haml",
+     patterns: 
+      [{comment: "Hack to let ruby comments work in this context properly",
+        match: /#.*$/,
+        name: "comment.line.number-sign.ruby"},
+       {include: "source.ruby.rails"},
+       {include: "#continuation"}]}},
+ scopeName: "text.haml",
+ uuid: "3D727049-DD05-45DF-92A5-D50EA36FD035"}