ver 2009.12.14 → 2010.02

data/config/syntax/Ruby on Rails.rb

@@ -0,0 +1,116 @@
+# Encoding: UTF-8
+
+{fileTypes: ["rb", "rxml", "builder"],
+ foldingStartMarker: 
+  /(?x)^
+	    (\s*+
+	        (module|class|def
+	        |unless|if
+	        |case
+	        |begin
+	        |for|while|until
+	        |(  "(\\.|[^"])*+"          # eat a double quoted string
+	         | '(\\.|[^'])*+'        # eat a single quoted string
+	         |   [^#"']                # eat all but comments and strings
+	         )*
+	         (                 \s   (do|begin|case)
+	         | [-+=&|*\/~%^<>~] \s*+ (if|unless)
+	         )
+	        )\b
+	        (?! [^;]*+ ; .*? \bend\b )
+	    |(  "(\\.|[^"])*+"              # eat a double quoted string
+	     | '(\\.|[^'])*+'            # eat a single quoted string
+	     |   [^#"']                    # eat all but comments and strings
+	     )*
+	     ( \{ (?!  [^}]*+ \} )
+	     | \[ (?! [^\]]*+ \] )
+	     )
+	    ).*$
+	|   [#] .*? \(fold\) \s*+ $         # Sune’s special marker
+	/,
+ foldingStopMarker: 
+  /(?x)
+	(   (^|;) \s*+ end   \s*+ ([#].*)? $
+	|   ^     \s*+ [}\]] \s*+ ([#].*)? $
+	|   [#] .*? \(end\) \s*+ $    # Sune’s special marker
+	)/,
+ keyEquivalent: "^~R",
+ name: "Ruby on Rails",
+ patterns: 
+  [{begin: 
+     /(^\s*)(?=class\s+(([.a-zA-Z0-9_:]+ControllerTest(\s*<\s*[.a-zA-Z0-9_:]+)?)))/,
+    comment: 
+     "Uses lookahead to match classes with the ControllerTest suffix; includes 'source.ruby' to avoid infinite recursion",
+    end: "^\\1(?=end)\\b",
+    name: "meta.rails.functional_test",
+    patterns: [{include: "source.ruby"}, {include: "$self"}]},
+   {begin: 
+     /(^\s*)(?=class\s+(([.a-zA-Z0-9_:]+Controller\b(\s*<\s*[.a-zA-Z0-9_:]+)?)|(<<\s*[.a-zA-Z0-9_:]+)))(?!.+\bend\b)/,
+    comment: 
+     "Uses lookahead to match classes with the Controller suffix; includes 'source.ruby' to avoid infinite recursion",
+    end: "^\\1(?=end)\\b",
+    name: "meta.rails.controller",
+    patterns: [{include: "source.ruby"}, {include: "$self"}]},
+   {begin: /(^\s*)(?=module\s+((([A-Z]\w*::)*)[A-Z]\w*)Helper)/,
+    comment: 
+     "Uses lookahead to match modules with the Helper suffix; includes 'source.ruby' to avoid infinite recursion",
+    end: "^\\1(?=end)\\b",
+    name: "meta.rails.helper",
+    patterns: [{include: "source.ruby"}, {include: "$self"}]},
+   {begin: /(^\s*)(?=class\s+(([.a-zA-Z0-9_:]+(\s*<\s*ActionMailer::Base))))/,
+    comment: 
+     "Uses lookahead to match classes that inherit from ActionMailer::Base; includes 'source.ruby' to avoid infinite recursion",
+    end: "^\\1(?=end)\\b",
+    name: "meta.rails.mailer",
+    patterns: [{include: "source.ruby"}, {include: "$self"}]},
+   {begin: /(^\s*)(?=class\s+.+ActiveRecord::Base)/,
+    comment: 
+     "Uses lookahead to match classes that (may) inherit from ActiveRecord::Base; includes 'source.ruby' to avoid infinite recursion",
+    end: "^\\1(?=end)\\b",
+    name: "meta.rails.model",
+    patterns: [{include: "source.ruby"}, {include: "$self"}]},
+   {begin: /(^\s*)(?=class\s+.+ActiveRecord::Migration)/,
+    comment: 
+     "Uses lookahead to match classes that (may) inherit from ActiveRecord::Migration; includes 'source.ruby' to avoid infinite recursion",
+    end: "^\\1(?=end)\\b",
+    name: "meta.rails.migration",
+    patterns: 
+     [{begin: /(^\s*)(?=change_table)\b/,
+       comment: 
+        "Uses lookahead to match methods change_table; includes 'source.ruby' to avoid infinite recursion",
+       contentName: "meta.rails.migration.change_table",
+       end: "^\\1(?=end)\\b",
+       patterns: [{include: "source.ruby"}, {include: "$self"}]},
+      {begin: /(^\s*)(?=create_table)\b/,
+       comment: 
+        "Uses lookahead to match methods create_table; includes 'source.ruby' to avoid infinite recursion",
+       contentName: "meta.rails.migration.create_table",
+       end: "^\\1(?=end)\\b",
+       patterns: [{include: "source.ruby"}, {include: "$self"}]},
+      {include: "source.ruby"},
+      {include: "$self"}]},
+   {begin: 
+     /(^\s*)(?=class\s+(?![.a-zA-Z0-9_:]+ControllerTest)(([.a-zA-Z0-9_:]+Test(\s*<\s*[.a-zA-Z0-9_:]+)?)|(<<\s*[.a-zA-Z0-9_:]+)))/,
+    comment: 
+     "Uses lookahead to match classes with the Test suffix; includes 'source.ruby' to avoid infinite recursion",
+    end: "^\\1(?=end)\\b",
+    name: "meta.rails.unit_test",
+    patterns: [{include: "source.ruby"}, {include: "$self"}]},
+   {begin: /(^\s*)ActionController::Routing::Routes/,
+    comment: 
+     "Uses ActionController::Routing::Routes to determine it is a routes file; includes 'source.ruby' to avoid infinite recursion",
+    end: "^\\1(?=end)\\b",
+    name: "meta.rails.routes",
+    patterns: [{include: "source.ruby"}, {include: "$self"}]},
+   {match: 
+     /\b(before_filter|skip_before_filter|skip_after_filter|after_filter|around_filter|filter|filter_parameter_logging|layout|require_dependency|render|render_action|render_text|render_file|render_template|render_nothing|render_component|render_without_layout|rescue_from|url_for|redirect_to|redirect_to_path|redirect_to_url|respond_to|helper|helper_method|model|service|observer|serialize|scaffold|verify|hide_action)\b/,
+    name: "support.function.actionpack.rails"},
+   {match: 
+     /\b(named_scope|after_create|after_destroy|after_save|after_update|after_validation|after_validation_on_create|after_validation_on_update|before_create|before_destroy|before_save|before_update|before_validation|before_validation_on_create|before_validation_on_update|composed_of|belongs_to|has_one|has_many|has_and_belongs_to_many|validate|validate_on_create|validates_numericality_of|validate_on_update|validates_acceptance_of|validates_associated|validates_confirmation_of|validates_each|validates_format_of|validates_inclusion_of|validates_exclusion_of|validates_length_of|validates_presence_of|validates_size_of|validates_uniqueness_of|attr_protected|attr_accessible|attr_readonly)\b/,
+    name: "support.function.activerecord.rails"},
+   {match: 
+     /\b(alias_method_chain|alias_attribute|delegate|cattr_accessor|mattr_accessor|returning)\b/,
+    name: "support.function.activesupport.rails"},
+   {include: "source.ruby"}],
+ scopeName: "source.ruby.rails",
+ uuid: "54D6E91E-8F31-11D9-90C5-0011242E4184"}

data/config/syntax/Ruby.rb

@@ -0,0 +1,758 @@
+# Encoding: UTF-8
+
+{comment: 
+  "\n\tTODO: unresolved issues\n\n\ttext:\n\t\"p << end\n\tprint me!\n\tend\"\n\tsymptoms:\n\tnot recognized as a heredoc\n\tsolution:\n\tthere is no way to distinguish perfectly between the << operator and the start\n\tof a heredoc. Currently, we require assignment to recognize a heredoc. More\n\trefinement is possible.\n\t• Heredocs with indented terminators (<<-) are always distinguishable, however.\n\t• Nested heredocs are not really supportable at present\n\n\ttext:\n\tprint <<-'THERE' \n\tThis is single quoted. \n\tThe above used \#{Time.now} \n\tTHERE \n\tsymtoms:\n\tFrom Programming Ruby p306; should be a non-interpolated heredoc.\n\t\n\ttext:\n\t\"a\\332a\"\n\tsymptoms:\n\t'\\332' is not recognized as slash3.. which should be octal 332.\n\tsolution:\n\tplain regexp.. should be easy.\n\n    text:\n    val?(a):p(b)\n    val?'a':'b'\n    symptoms:\n    ':p' is recognized as a symbol.. its 2 things ':' and 'p'.\n    :'b' has same problem.\n    solution:\n    ternary operator rule, precedence stuff, symbol rule.\n    but also consider 'a.b?(:c)' ??\n",
+ fileTypes: 
+  ["rb",
+   "rbx",
+   "rjs",
+   "Rakefile",
+   "rake",
+   "cgi",
+   "fcgi",
+   "gemspec",
+   "irbrc",
+   "capfile"],
+ firstLineMatch: "^#!/.*\\bruby\\b",
+ foldingStartMarker: 
+  /(?x)^
+	    (\s*+
+	        (module|class|def(?!.*\bend\s*$)
+	        |unless|if
+	        |case
+	        |begin
+	        |for|while|until
+	         |^=begin
+	        |(  "(\\.|[^"])*+"          # eat a double quoted string
+	         | '(\\.|[^'])*+'        # eat a single quoted string
+	         |   [^#"']                # eat all but comments and strings
+	         )*
+	         (                        \s   (do|begin|case)
+	         | (?<!\$)[-+=&|*\/~%^<>~] \s*+ (if|unless)
+	         )
+	        )\b
+	        (?! [^;]*+ ; .*? \bend\b )
+	    |(  "(\\.|[^"])*+"              # eat a double quoted string
+	     | '(\\.|[^'])*+'            # eat a single quoted string
+	     |   [^#"']                    # eat all but comments and strings
+	     )*
+	     ( \{ (?!  [^}]*+ \} )
+	     | \[ (?! [^\]]*+ \] )
+	     )
+	    ).*$
+	|   [#] .*? \(fold\) \s*+ $         # Sune’s special marker
+	/,
+ foldingStopMarker: 
+  /(?x)
+	(   (^|;) \s*+ end   \s*+ ([#].*)? $
+	|   (^|;) \s*+ end \. .* $
+	|   ^     \s*+ [}\]] ,? \s*+ ([#].*)? $
+	|   [#] .*? \(end\) \s*+ $    # Sune’s special marker
+	|   ^=end
+	)/,
+ keyEquivalent: /^~R/,
+ name: "Ruby",
+ patterns: 
+  [{captures: 
+     {1 => {name: "keyword.control.class.ruby"},
+      2 => {name: "entity.name.type.class.ruby"},
+      4 => {name: "entity.other.inherited-class.ruby"},
+      5 => {name: "punctuation.separator.inheritance.ruby"},
+      6 => {name: "variable.other.object.ruby"},
+      7 => {name: "punctuation.definition.variable.ruby"}},
+    match: 
+     /^\s*(class)\s+(([.a-zA-Z0-9_:]+(\s*(<)\s*[.a-zA-Z0-9_:]+)?)|((<<)\s*[.a-zA-Z0-9_:]+))/,
+    name: "meta.class.ruby"},
+   {captures: 
+     {1 => {name: "keyword.control.module.ruby"},
+      2 => {name: "entity.name.type.module.ruby"},
+      3 => {name: "entity.other.inherited-class.module.first.ruby"},
+      4 => {name: "punctuation.separator.inheritance.ruby"},
+      5 => {name: "entity.other.inherited-class.module.second.ruby"},
+      6 => {name: "punctuation.separator.inheritance.ruby"},
+      7 => {name: "entity.other.inherited-class.module.third.ruby"},
+      8 => {name: "punctuation.separator.inheritance.ruby"}},
+    match: 
+     /^\s*(module)\s+(([A-Z]\w*(::))?([A-Z]\w*(::))?([A-Z]\w*(::))*[A-Z]\w*)/,
+    name: "meta.module.ruby"},
+   {comment: 
+     "else if is a common mistake carried over from other languages. it works if you put in a second end, but it’s never what you want.",
+    match: /(?<!\.)\belse(\s)+if\b/,
+    name: "invalid.deprecated.ruby"},
+   {comment: 
+     "everything being a reserved word, not a value and needing a 'end' is a..",
+    match: 
+     /(?<!\.)\b(BEGIN|begin|case|class|else|elsif|END|end|ensure|for|if|in|module|rescue|then|unless|until|when|while)\b(?![?!])/,
+    name: "keyword.control.ruby"},
+   {comment: "contextual smart pair support for block parameters",
+    match: /(?<!\.)\bdo\b\s*/,
+    name: "keyword.control.start-block.ruby"},
+   {comment: "contextual smart pair support",
+    match: /(?<=\{)(\s+)/,
+    name: "meta.syntax.ruby.start-block"},
+   {comment: " as above, just doesn't need a 'end' and does a logic operation",
+    match: /(?<!\.)\b(and|not|or)\b/,
+    name: "keyword.operator.logical.ruby"},
+   {comment: " just as above but being not a logical operation",
+    match: 
+     /(?<!\.)\b(alias|alias_method|break|next|redo|retry|return|super|undef|yield)\b(?![?!])|\bdefined\?|\bblock_given\?/,
+    name: "keyword.control.pseudo-method.ruby"},
+   {match: /\b(nil|true|false)\b(?![?!])/, name: "constant.language.ruby"},
+   {match: /\b(__(FILE|LINE)__|self)\b(?![?!])/,
+    name: "variable.language.ruby"},
+   {comment: " everything being a method but having a special function is a..",
+    match: 
+     /\b(initialize|new|loop|include|extend|raise|attr_reader|attr_writer|attr_accessor|attr|catch|throw|private|module_function|public|protected)\b(?![?!])/,
+    name: "keyword.other.special-method.ruby"},
+   {begin: /\b(require|gem)\b/,
+    captures: {1 => {name: "keyword.other.special-method.ruby"}},
+    end: "$|(?=#)",
+    name: "meta.require.ruby",
+    patterns: [{include: "$self"}]},
+   {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"},
+   {captures: {1 => {name: "punctuation.definition.variable.ruby"}},
+    match: 
+     /(\$)(!|@|&|`|'|\+|\d+|~|=|\/|\\|,|;|\.|<|>|_|\*|\$|\?|:|"|-[0adFiIlpv])/,
+    name: "variable.other.readwrite.global.pre-defined.ruby"},
+   {begin: /\b(ENV)\[/,
+    beginCaptures: {1 => {name: "variable.other.constant.ruby"}},
+    end: "\\]",
+    name: "meta.environment-variable.ruby",
+    patterns: [{include: "$self"}]},
+   {match: /\b[A-Z]\w*(?=((\.|::)[A-Za-z]|\[))/, name: "support.class.ruby"},
+   {match: /\b[A-Z]\w*\b/, name: "variable.other.constant.ruby"},
+   {begin: 
+     /(?x)
+	         (?=def\b)                                                      # an optimization to help Oniguruma fail fast
+	         (?<=^|\s)(def)\s+                                              # the def keyword
+	         ( (?>[a-zA-Z_]\w*(?>\.|::))?                                   # a method name prefix
+	           (?>[a-zA-Z_]\w*(?>[?!]|=(?!>))?                              # the method name
+	           |===?|>[>=]?|<=>|<[<=]?|[%&`\/\|]|\*\*?|=?~|[-+]@?|\[\]=?) )  # …or an operator method
+	         \s*(\()                                                        # the openning parenthesis for arguments
+	        /,
+    beginCaptures: 
+     {1 => {name: "keyword.control.def.ruby"},
+      2 => {name: "entity.name.function.ruby"},
+      3 => {name: "punctuation.definition.parameters.ruby"}},
+    comment: 
+     "the method pattern comes from the symbol pattern, see there for a explaination",
+    contentName: "variable.parameter.function.ruby",
+    end: "\\)",
+    endCaptures: {0 => {name: "punctuation.definition.parameters.ruby"}},
+    name: "meta.function.method.with-arguments.ruby",
+    patterns: [{include: "$self"}]},
+   {begin: 
+     /(?x)
+	         (?=def\b)                                                      # an optimization to help Oniguruma fail fast
+	         (?<=^|\s)(def)\s+                                              # the def keyword
+	         ( (?>[a-zA-Z_]\w*(?>\.|::))?                                   # a method name prefix
+	           (?>[a-zA-Z_]\w*(?>[?!]|=(?!>))?                              # the method name
+	           |===?|>[>=]?|<=>|<[<=]?|[%&`\/\|]|\*\*?|=?~|[-+]@?|\[\]=?) )  # …or an operator method
+	         [ \t]                                                          # the space separating the arguments
+	         (?=[ \t]*[^\s#])                                               # make sure arguments and not a comment follow
+	        /,
+    beginCaptures: 
+     {1 => {name: "keyword.control.def.ruby"},
+      2 => {name: "entity.name.function.ruby"}},
+    comment: 
+     "same as the previous rule, but without parentheses around the arguments",
+    contentName: "variable.parameter.function.ruby",
+    end: "$",
+    name: "meta.function.method.with-arguments.ruby",
+    patterns: [{include: "$self"}]},
+   {captures: 
+     {1 => {name: "keyword.control.def.ruby"},
+      3 => {name: "entity.name.function.ruby"}},
+    comment: 
+     " the optional name is just to catch the def also without a method-name",
+    match: 
+     /(?x)
+	         (?=def\b)                                                           # an optimization to help Oniguruma fail fast
+	         (?<=^|\s)(def)\b                                                    # the def keyword
+	         ( \s+                                                               # an optional group of whitespace followed by…
+	           ( (?>[a-zA-Z_]\w*(?>\.|::))?                                      # a method name prefix
+	             (?>[a-zA-Z_]\w*(?>[?!]|=(?!>))?                                 # the method name
+	             |===?|>[>=]?|<=>|<[<=]?|[%&`\/\|]|\*\*?|=?~|[-+]@?|\[\]=?) ) )?  # …or an operator method
+	        /,
+    name: "meta.function.method.without-arguments.ruby"},
+   {match: 
+     /\b(0[xX]\h(?>_?\h)*|\d(?>_?\d)*(\.(?![^[:space:][:digit:]])(?>_?\d)*)?([eE][-+]?\d(?>_?\d)*)?|0[bB][01]+)\b/,
+    name: "constant.numeric.ruby"},
+   {begin: /:'/,
+    captures: {0 => {name: "punctuation.definition.constant.ruby"}},
+    end: "'",
+    name: "constant.other.symbol.single-quoted.ruby",
+    patterns: [{match: /\\['\\]/, name: "constant.character.escape.ruby"}]},
+   {begin: /:"/,
+    captures: {0 => {name: "punctuation.definition.constant.ruby"}},
+    end: "\"",
+    name: "constant.other.symbol.double-quoted.ruby",
+    patterns: [{include: "#interpolated_ruby"}, {include: "#escaped_char"}]},
+   {comment: "Needs higher precidence than regular expressions.",
+    match: /\/=/,
+    name: "keyword.operator.assignment.augmented.ruby"},
+   {begin: /'/,
+    beginCaptures: {0 => {name: "punctuation.definition.string.begin.ruby"}},
+    comment: "single quoted string (does not allow interpolation)",
+    end: "'",
+    endCaptures: {0 => {name: "punctuation.definition.string.end.ruby"}},
+    name: "string.quoted.single.ruby",
+    patterns: [{match: /\\'|\\\\/, name: "constant.character.escape.ruby"}]},
+   {begin: /"/,
+    beginCaptures: {0 => {name: "punctuation.definition.string.begin.ruby"}},
+    comment: "double quoted string (allows for interpolation)",
+    end: "\"",
+    endCaptures: {0 => {name: "punctuation.definition.string.end.ruby"}},
+    name: "string.quoted.double.ruby",
+    patterns: [{include: "#interpolated_ruby"}, {include: "#escaped_char"}]},
+   {begin: /`/,
+    beginCaptures: {0 => {name: "punctuation.definition.string.begin.ruby"}},
+    comment: "execute string (allows for interpolation)",
+    end: "`",
+    endCaptures: {0 => {name: "punctuation.definition.string.end.ruby"}},
+    name: "string.interpolated.ruby",
+    patterns: [{include: "#interpolated_ruby"}, {include: "#escaped_char"}]},
+   {begin: /%x\{/,
+    beginCaptures: {0 => {name: "punctuation.definition.string.begin.ruby"}},
+    comment: "execute string (allow for interpolation)",
+    end: "\\}",
+    endCaptures: {0 => {name: "punctuation.definition.string.end.ruby"}},
+    name: "string.interpolated.ruby",
+    patterns: 
+     [{include: "#interpolated_ruby"},
+      {include: "#escaped_char"},
+      {include: "#nest_curly_i"}]},
+   {begin: /%x\[/,
+    beginCaptures: {0 => {name: "punctuation.definition.string.begin.ruby"}},
+    comment: "execute string (allow for interpolation)",
+    end: "\\]",
+    endCaptures: {0 => {name: "punctuation.definition.string.end.ruby"}},
+    name: "string.interpolated.ruby",
+    patterns: 
+     [{include: "#interpolated_ruby"},
+      {include: "#escaped_char"},
+      {include: "#nest_brackets_i"}]},
+   {begin: /%x\</,
+    beginCaptures: {0 => {name: "punctuation.definition.string.begin.ruby"}},
+    comment: "execute string (allow for interpolation)",
+    end: "\\>",
+    endCaptures: {0 => {name: "punctuation.definition.string.end.ruby"}},
+    name: "string.interpolated.ruby",
+    patterns: 
+     [{include: "#interpolated_ruby"},
+      {include: "#escaped_char"},
+      {include: "#nest_ltgt_i"}]},
+   {begin: /%x\(/,
+    beginCaptures: {0 => {name: "punctuation.definition.string.begin.ruby"}},
+    comment: "execute string (allow for interpolation)",
+    end: "\\)",
+    endCaptures: {0 => {name: "punctuation.definition.string.end.ruby"}},
+    name: "string.interpolated.ruby",
+    patterns: 
+     [{include: "#interpolated_ruby"},
+      {include: "#escaped_char"},
+      {include: "#nest_parens_i"}]},
+   {begin: /%x([^\w])/,
+    beginCaptures: {0 => {name: "punctuation.definition.string.begin.ruby"}},
+    comment: "execute string (allow for interpolation)",
+    end: "\\1",
+    endCaptures: {0 => {name: "punctuation.definition.string.end.ruby"}},
+    name: "string.interpolated.ruby",
+    patterns: [{include: "#interpolated_ruby"}, {include: "#escaped_char"}]},
+   {begin: 
+     /(?x)
+	   (?:
+	     ^                      # beginning of line
+	   | (?<=                   # or look-behind on:
+	       [=>~(?:\[,|&;]
+	     | [\s;]if\s			# keywords
+	     | [\s;]elsif\s
+	     | [\s;]while\s
+	     | [\s;]unless\s
+	     | [\s;]when\s
+	     | [\s;]assert_match\s
+	     | [\s;]or\s			# boolean opperators
+	     | [\s;]and\s
+	     | [\s;]not\s
+	     | [\s.]index\s			# methods
+	     | [\s.]scan\s
+	     | [\s.]sub\s
+	     | [\s.]sub!\s
+	     | [\s.]gsub\s
+	     | [\s.]gsub!\s
+	     | [\s.]match\s
+	     )
+	   | (?<=                  # or a look-behind with line anchor:
+	        ^when\s            # duplication necessary due to limits of regex
+	      | ^if\s
+	      | ^elsif\s
+	      | ^while\s
+	      | ^unless\s
+	      )
+	   )
+	   \s*((\/))(?![*+{}?])
+	/,
+    captures: 
+     {1 => {name: "string.regexp.classic.ruby"},
+      2 => {name: "punctuation.definition.string.ruby"}},
+    comment: 
+     "regular expressions (normal)\n\t\t\twe only start a regexp if the character before it (excluding whitespace)\n\t\t\tis what we think is before a regexp\n\t\t\t",
+    contentName: "string.regexp.classic.ruby",
+    end: "((/[eimnosux]*))",
+    patterns: [{include: "#regex_sub"}]},
+   {begin: /%r\{/,
+    beginCaptures: {0 => {name: "punctuation.definition.string.begin.ruby"}},
+    comment: "regular expressions (literal)",
+    end: "\\}[eimnosux]*",
+    endCaptures: {0 => {name: "punctuation.definition.string.end.ruby"}},
+    name: "string.regexp.mod-r.ruby",
+    patterns: [{include: "#regex_sub"}, {include: "#nest_curly_r"}]},
+   {begin: /%r\[/,
+    beginCaptures: {0 => {name: "punctuation.definition.string.begin.ruby"}},
+    comment: "regular expressions (literal)",
+    end: "\\][eimnosux]*",
+    endCaptures: {0 => {name: "punctuation.definition.string.end.ruby"}},
+    name: "string.regexp.mod-r.ruby",
+    patterns: [{include: "#regex_sub"}, {include: "#nest_brackets_r"}]},
+   {begin: /%r\(/,
+    beginCaptures: {0 => {name: "punctuation.definition.string.begin.ruby"}},
+    comment: "regular expressions (literal)",
+    end: "\\)[eimnosux]*",
+    endCaptures: {0 => {name: "punctuation.definition.string.end.ruby"}},
+    name: "string.regexp.mod-r.ruby",
+    patterns: [{include: "#regex_sub"}, {include: "#nest_parens_r"}]},
+   {begin: /%r\</,
+    beginCaptures: {0 => {name: "punctuation.definition.string.begin.ruby"}},
+    comment: "regular expressions (literal)",
+    end: "\\>[eimnosux]*",
+    endCaptures: {0 => {name: "punctuation.definition.string.end.ruby"}},
+    name: "string.regexp.mod-r.ruby",
+    patterns: [{include: "#regex_sub"}, {include: "#nest_ltgt_r"}]},
+   {begin: /%r([^\w])/,
+    beginCaptures: {0 => {name: "punctuation.definition.string.begin.ruby"}},
+    comment: "regular expressions (literal)",
+    end: "\\1[eimnosux]*",
+    endCaptures: {0 => {name: "punctuation.definition.string.end.ruby"}},
+    name: "string.regexp.mod-r.ruby",
+    patterns: [{include: "#regex_sub"}]},
+   {begin: /%[QWSR]?\(/,
+    beginCaptures: {0 => {name: "punctuation.definition.string.begin.ruby"}},
+    comment: "literal capable of interpolation ()",
+    end: "\\)",
+    endCaptures: {0 => {name: "punctuation.definition.string.end.ruby"}},
+    name: "string.quoted.other.literal.upper.ruby",
+    patterns: 
+     [{include: "#interpolated_ruby"},
+      {include: "#escaped_char"},
+      {include: "#nest_parens_i"}]},
+   {begin: /%[QWSR]?\[/,
+    beginCaptures: {0 => {name: "punctuation.definition.string.begin.ruby"}},
+    comment: "literal capable of interpolation []",
+    end: "\\]",
+    endCaptures: {0 => {name: "punctuation.definition.string.end.ruby"}},
+    name: "string.quoted.other.literal.upper.ruby",
+    patterns: 
+     [{include: "#interpolated_ruby"},
+      {include: "#escaped_char"},
+      {include: "#nest_brackets_i"}]},
+   {begin: /%[QWSR]?\</,
+    beginCaptures: {0 => {name: "punctuation.definition.string.begin.ruby"}},
+    comment: "literal capable of interpolation <>",
+    end: "\\>",
+    endCaptures: {0 => {name: "punctuation.definition.string.end.ruby"}},
+    name: "string.quoted.other.literal.upper.ruby",
+    patterns: 
+     [{include: "#interpolated_ruby"},
+      {include: "#escaped_char"},
+      {include: "#nest_ltgt_i"}]},
+   {begin: /%[QWSR]?\{/,
+    beginCaptures: {0 => {name: "punctuation.definition.string.begin.ruby"}},
+    comment: "literal capable of interpolation -- {}",
+    end: "\\}",
+    endCaptures: {0 => {name: "punctuation.definition.string.end.ruby"}},
+    name: "string.quoted.double.ruby.mod",
+    patterns: 
+     [{include: "#interpolated_ruby"},
+      {include: "#escaped_char"},
+      {include: "#nest_curly_i"}]},
+   {begin: /%[QWSR]([^\w])/,
+    beginCaptures: {0 => {name: "punctuation.definition.string.begin.ruby"}},
+    comment: "literal capable of interpolation -- wildcard",
+    end: "\\1",
+    endCaptures: {0 => {name: "punctuation.definition.string.end.ruby"}},
+    name: "string.quoted.other.literal.upper.ruby",
+    patterns: [{include: "#interpolated_ruby"}, {include: "#escaped_char"}]},
+   {begin: /%([^\w\s=])/,
+    beginCaptures: {0 => {name: "punctuation.definition.string.begin.ruby"}},
+    comment: "literal capable of interpolation -- wildcard",
+    end: "\\1",
+    endCaptures: {0 => {name: "punctuation.definition.string.end.ruby"}},
+    name: "string.quoted.other.literal.other.ruby",
+    patterns: [{include: "#interpolated_ruby"}, {include: "#escaped_char"}]},
+   {begin: /%[qws]\(/,
+    beginCaptures: {0 => {name: "punctuation.definition.string.begin.ruby"}},
+    comment: "literal incapable of interpolation -- ()",
+    end: "\\)",
+    endCaptures: {0 => {name: "punctuation.definition.string.end.ruby"}},
+    name: "string.quoted.other.literal.lower.ruby",
+    patterns: 
+     [{match: /\\\)|\\\\/, name: "constant.character.escape.ruby"},
+      {include: "#nest_parens"}]},
+   {begin: /%[qws]\</,
+    beginCaptures: {0 => {name: "punctuation.definition.string.begin.ruby"}},
+    comment: "literal incapable of interpolation -- <>",
+    end: "\\>",
+    endCaptures: {0 => {name: "punctuation.definition.string.end.ruby"}},
+    name: "string.quoted.other.literal.lower.ruby",
+    patterns: 
+     [{match: /\\\>|\\\\/, name: "constant.character.escape.ruby"},
+      {include: "#nest_ltgt"}]},
+   {begin: /%[qws]\[/,
+    beginCaptures: {0 => {name: "punctuation.definition.string.begin.ruby"}},
+    comment: "literal incapable of interpolation -- []",
+    end: "\\]",
+    endCaptures: {0 => {name: "punctuation.definition.string.end.ruby"}},
+    name: "string.quoted.other.literal.lower.ruby",
+    patterns: 
+     [{match: /\\\]|\\\\/, name: "constant.character.escape.ruby"},
+      {include: "#nest_brackets"}]},
+   {begin: /%[qws]\{/,
+    beginCaptures: {0 => {name: "punctuation.definition.string.begin.ruby"}},
+    comment: "literal incapable of interpolation -- {}",
+    end: "\\}",
+    endCaptures: {0 => {name: "punctuation.definition.string.end.ruby"}},
+    name: "string.quoted.other.literal.lower.ruby",
+    patterns: 
+     [{match: /\\\}|\\\\/, name: "constant.character.escape.ruby"},
+      {include: "#nest_curly"}]},
+   {begin: /%[qws]([^\w])/,
+    beginCaptures: {0 => {name: "punctuation.definition.string.begin.ruby"}},
+    comment: "literal incapable of interpolation -- wildcard",
+    end: "\\1",
+    endCaptures: {0 => {name: "punctuation.definition.string.end.ruby"}},
+    name: "string.quoted.other.literal.lower.ruby",
+    patterns: 
+     [{comment: "Cant be named because its not neccesarily an escape.",
+       match: /\\./}]},
+   {captures: {1 => {name: "punctuation.definition.constant.ruby"}},
+    comment: "symbols",
+    match: 
+     /(?<!:)(:)(?>[a-zA-Z_]\w*(?>[?!]|=(?![>=]))?|===?|>[>=]?|<[<=]?|<=>|[%&`\/\|]|\*\*?|=?~|[-+]@?|\[\]=?|@@?[a-zA-Z_]\w*)/,
+    name: "constant.other.symbol.ruby"},
+   {captures: {1 => {name: "punctuation.definition.constant.ruby"}},
+    comment: "symbols",
+    match: 
+     /(?>[a-zA-Z_]\w*(?>[?!]|=(?![>=]))?|===?|>[>=]?|<[<=]?|<=>|[%`\/\|]|\*\*?|=?~|[-+]@?|\[\]=?|@@?[a-zA-Z_]\w*)(:)(?!:)/,
+    name: "constant.other.symbol.ruby.19syntax"},
+   {begin: /^=begin/,
+    captures: {0 => {name: "punctuation.definition.comment.ruby"}},
+    comment: "multiline comments",
+    end: "^=end",
+    name: "comment.block.documentation.ruby"},
+   {captures: {1 => {name: "punctuation.definition.comment.ruby"}},
+    match: /(?:^[ \t]+)?(#).*$\n?/,
+    name: "comment.line.number-sign.ruby"},
+   {comment: 
+     "\n\t\t\tmatches questionmark-letters.\n\n\t\t\texamples (1st alternation = hex):\n\t\t\t?\\x1     ?\\x61\n\n\t\t\texamples (2nd alternation = octal):\n\t\t\t?\\0      ?\\07     ?\\017\n\n\t\t\texamples (3rd alternation = escaped):\n\t\t\t?\\n      ?\\b\n\n\t\t\texamples (4th alternation = meta-ctrl):\n\t\t\t?\\C-a    ?\\M-a    ?\\C-\\M-\\C-\\M-a\n\n\t\t\texamples (4th alternation = normal):\n\t\t\t?a       ?A       ?0 \n\t\t\t?*       ?\"       ?( \n\t\t\t?.       ?#\n\t\t\t\n\t\t\t\n\t\t\tthe negative lookbehind prevents against matching\n\t\t\tp(42.tainted?)\n\t\t\t",
+    match: 
+     /(?<!\w)\?(\\(x\h{1,2}(?!\h)\b|0[0-7]{0,2}(?![0-7])\b|[^x0MC])|(\\[MC]-)+\w|[^\s\\])/,
+    name: "constant.numeric.ruby"},
+   {begin: /^__END__\n/,
+    captures: {0 => {name: "string.unquoted.program-block.ruby"}},
+    comment: "__END__ marker",
+    contentName: "text.plain",
+    end: "(?=not)impossible",
+    patterns: 
+     [{begin: /(?=<?xml|<(?i:html\b)|!DOCTYPE (?i:html\b))/,
+       end: "(?=not)impossible",
+       name: "text.html.embedded.ruby",
+       patterns: [{include: "text.html.basic"}]}]},
+   {begin: /(?><<-("?)((?:[_\w]+_|)HTML)\b\1)/,
+    beginCaptures: {0 => {name: "punctuation.definition.string.begin.ruby"}},
+    comment: "heredoc with embedded HTML and indented terminator",
+    contentName: "text.html.embedded.ruby",
+    end: "\\s*\\2$",
+    endCaptures: {0 => {name: "punctuation.definition.string.end.ruby"}},
+    name: "string.unquoted.embedded.html.ruby",
+    patterns: 
+     [{include: "#heredoc"},
+      {include: "text.html.basic"},
+      {include: "#interpolated_ruby"},
+      {include: "#escaped_char"}]},
+   {begin: /(?><<-("?)((?:[_\w]+_|)SQL)\b\1)/,
+    beginCaptures: {0 => {name: "punctuation.definition.string.begin.ruby"}},
+    comment: "heredoc with embedded SQL and indented terminator",
+    contentName: "text.sql.embedded.ruby",
+    end: "\\s*\\2$",
+    endCaptures: {0 => {name: "punctuation.definition.string.end.ruby"}},
+    name: "string.unquoted.embedded.sql.ruby",
+    patterns: 
+     [{include: "#heredoc"},
+      {include: "source.sql"},
+      {include: "#interpolated_ruby"},
+      {include: "#escaped_char"}]},
+   {begin: /(?><<-("?)((?:[_\w]+_|)CSS)\b\1)/,
+    beginCaptures: {0 => {name: "punctuation.definition.string.begin.ruby"}},
+    comment: "heredoc with embedded css and intented terminator",
+    contentName: "text.css.embedded.ruby",
+    end: "\\s*\\2$",
+    endCaptures: {0 => {name: "punctuation.definition.string.end.ruby"}},
+    name: "string.unquoted.embedded.css.ruby",
+    patterns: 
+     [{include: "#heredoc"},
+      {include: "source.css"},
+      {include: "#interpolated_ruby"},
+      {include: "#escaped_char"}]},
+   {begin: /(?><<-("?)((?:[_\w]+_|)CPP)\b\1)/,
+    beginCaptures: {0 => {name: "punctuation.definition.string.begin.ruby"}},
+    comment: "heredoc with embedded c++ and intented terminator",
+    contentName: "text.c++.embedded.ruby",
+    end: "\\s*\\2$",
+    endCaptures: {0 => {name: "punctuation.definition.string.end.ruby"}},
+    name: "string.unquoted.embedded.cplusplus.ruby",
+    patterns: 
+     [{include: "#heredoc"},
+      {include: "source.c++"},
+      {include: "#interpolated_ruby"},
+      {include: "#escaped_char"}]},
+   {begin: /(?><<-("?)((?:[_\w]+_|)C)\b\1)/,
+    beginCaptures: {0 => {name: "punctuation.definition.string.begin.ruby"}},
+    comment: "heredoc with embedded c++ and intented terminator",
+    contentName: "text.c.embedded.ruby",
+    end: "\\s*\\2$",
+    endCaptures: {0 => {name: "punctuation.definition.string.end.ruby"}},
+    name: "string.unquoted.embedded.c.ruby",
+    patterns: 
+     [{include: "#heredoc"},
+      {include: "source.c"},
+      {include: "#interpolated_ruby"},
+      {include: "#escaped_char"}]},
+   {begin: /(?><<-("?)((?:[_\w]+_|)(?:JS|JAVASCRIPT))\b\1)/,
+    beginCaptures: {0 => {name: "punctuation.definition.string.begin.ruby"}},
+    comment: "heredoc with embedded javascript and intented terminator",
+    contentName: "text.js.embedded.ruby",
+    end: "\\s*\\2$",
+    endCaptures: {0 => {name: "punctuation.definition.string.end.ruby"}},
+    name: "string.unquoted.embedded.js.ruby",
+    patterns: 
+     [{include: "#heredoc"},
+      {include: "source.js"},
+      {include: "#interpolated_ruby"},
+      {include: "#escaped_char"}]},
+   {begin: /(?><<-("?)((?:[_\w]+_|)JQUERY)\b\1)/,
+    beginCaptures: {0 => {name: "punctuation.definition.string.begin.ruby"}},
+    comment: "heredoc with embedded javascript and intented terminator",
+    contentName: "text.js.jquery.embedded.ruby",
+    end: "\\s*\\2$",
+    endCaptures: {0 => {name: "punctuation.definition.string.end.ruby"}},
+    name: "string.unquoted.embedded.js.jquery.ruby",
+    patterns: 
+     [{include: "#heredoc"},
+      {include: "source.js.jquery"},
+      {include: "#interpolated_ruby"},
+      {include: "#escaped_char"}]},
+   {begin: /(?><<-("?)((?:[_\w]+_|)(?:SH|SHELL))\b\1)/,
+    beginCaptures: {0 => {name: "punctuation.definition.string.begin.ruby"}},
+    comment: "heredoc with embedded shell and intented terminator",
+    contentName: "text.shell.embedded.ruby",
+    end: "\\s*\\2$",
+    endCaptures: {0 => {name: "punctuation.definition.string.end.ruby"}},
+    name: "string.unquoted.embedded.shell.ruby",
+    patterns: 
+     [{include: "#heredoc"},
+      {include: "source.shell"},
+      {include: "#interpolated_ruby"},
+      {include: "#escaped_char"}]},
+   {begin: /(?><<-("?)((?:[_\w]+_|)RUBY)\b\1)/,
+    beginCaptures: {0 => {name: "punctuation.definition.string.begin.ruby"}},
+    comment: "heredoc with embedded ruby and intented terminator",
+    contentName: "text.ruby.embedded.ruby",
+    end: "\\s*\\2$",
+    endCaptures: {0 => {name: "punctuation.definition.string.end.ruby"}},
+    name: "string.unquoted.embedded.ruby.ruby",
+    patterns: 
+     [{include: "#heredoc"},
+      {include: "source.ruby"},
+      {include: "#interpolated_ruby"},
+      {include: "#escaped_char"}]},
+   {begin: /(?>\=\s*<<(\w+))/,
+    beginCaptures: {0 => {name: "punctuation.definition.string.begin.ruby"}},
+    end: "^\\1$",
+    endCaptures: {0 => {name: "punctuation.definition.string.end.ruby"}},
+    name: "string.unquoted.heredoc.ruby",
+    patterns: 
+     [{include: "#heredoc"},
+      {include: "#interpolated_ruby"},
+      {include: "#escaped_char"}]},
+   {begin: /(?><<-(\w+))/,
+    beginCaptures: {0 => {name: "punctuation.definition.string.begin.ruby"}},
+    comment: "heredoc with indented terminator",
+    end: "\\s*\\1$",
+    endCaptures: {0 => {name: "punctuation.definition.string.end.ruby"}},
+    name: "string.unquoted.heredoc.ruby",
+    patterns: 
+     [{include: "#heredoc"},
+      {include: "#interpolated_ruby"},
+      {include: "#escaped_char"}]},
+   {begin: /(?<=\{|do|\{\s|do\s)(\|)/,
+    captures: {1 => {name: "punctuation.separator.variable.ruby"}},
+    end: "(\\|)",
+    patterns: 
+     [{match: /[_a-zA-Z][_a-zA-Z0-9]*/, name: "variable.other.block.ruby"},
+      {match: /,/, name: "punctuation.separator.variable.ruby"}]},
+   {match: /=>/, name: "punctuation.separator.key-value"},
+   {match: /<<=|%=|&=|\*=|\*\*=|\+=|\-=|\^=|\|{1,2}=|<</,
+    name: "keyword.operator.assignment.augmented.ruby"},
+   {match: /<=>|<(?!<|=)|>(?!<|=|>)|<=|>=|===|==|=~|!=|!~|(?<=[ \t])\?/,
+    name: "keyword.operator.comparison.ruby"},
+   {match: /(?<=[ \t])!+|\bnot\b|&&|\band\b|\|\||\bor\b|\^/,
+    name: "keyword.operator.logical.ruby"},
+   {match: /(%|&|\*\*|\*|\+|\-|\/)/, name: "keyword.operator.arithmetic.ruby"},
+   {match: /=/, name: "keyword.operator.assignment.ruby"},
+   {match: /\||~|>>/, name: "keyword.operator.other.ruby"},
+   {match: /:/, name: "punctuation.separator.other.ruby"},
+   {match: /\;/, name: "punctuation.separator.statement.ruby"},
+   {match: /,/, name: "punctuation.separator.object.ruby"},
+   {match: /\.|::/, name: "punctuation.separator.method.ruby"},
+   {match: /\{|\}/, name: "punctuation.section.scope.ruby"},
+   {match: /\[|\]/, name: "punctuation.section.array.ruby"},
+   {match: /\(|\)/, name: "punctuation.section.function.ruby"}],
+ repository: 
+  {escaped_char: 
+    {match: /\\(?:[0-7]{1,3}|x[\da-fA-F]{1,2}|.)/,
+     name: "constant.character.escape.ruby"},
+   heredoc: {begin: /^<<-?\w+/, end: "$", patterns: [{include: "$self"}]},
+   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: "$self"}]},
+       {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_brackets: 
+    {begin: /\[/,
+     captures: {0 => {name: "punctuation.section.scope.ruby"}},
+     end: "\\]",
+     patterns: [{include: "#nest_brackets"}]},
+   nest_brackets_i: 
+    {begin: /\[/,
+     captures: {0 => {name: "punctuation.section.scope.ruby"}},
+     end: "\\]",
+     patterns: 
+      [{include: "#interpolated_ruby"},
+       {include: "#escaped_char"},
+       {include: "#nest_brackets_i"}]},
+   nest_brackets_r: 
+    {begin: /\[/,
+     captures: {0 => {name: "punctuation.section.scope.ruby"}},
+     end: "\\]",
+     patterns: [{include: "#regex_sub"}, {include: "#nest_brackets_r"}]},
+   nest_curly: 
+    {begin: /\{/,
+     captures: {0 => {name: "punctuation.section.scope.ruby"}},
+     end: "\\}",
+     patterns: [{include: "#nest_curly"}]},
+   nest_curly_and_self: 
+    {patterns: 
+      [{begin: /\{/,
+        captures: {0 => {name: "punctuation.section.scope.ruby"}},
+        end: "\\}",
+        patterns: [{include: "#nest_curly_and_self"}]},
+       {include: "$self"}]},
+   nest_curly_i: 
+    {begin: /\{/,
+     captures: {0 => {name: "punctuation.section.scope.ruby"}},
+     end: "\\}",
+     patterns: 
+      [{include: "#interpolated_ruby"},
+       {include: "#escaped_char"},
+       {include: "#nest_curly_i"}]},
+   nest_curly_r: 
+    {begin: /\{/,
+     captures: {0 => {name: "punctuation.section.scope.ruby"}},
+     end: "\\}",
+     patterns: [{include: "#regex_sub"}, {include: "#nest_curly_r"}]},
+   nest_ltgt: 
+    {begin: /\</,
+     captures: {0 => {name: "punctuation.section.scope.ruby"}},
+     end: "\\>",
+     patterns: [{include: "#nest_ltgt"}]},
+   nest_ltgt_i: 
+    {begin: /\</,
+     captures: {0 => {name: "punctuation.section.scope.ruby"}},
+     end: "\\>",
+     patterns: 
+      [{include: "#interpolated_ruby"},
+       {include: "#escaped_char"},
+       {include: "#nest_ltgt_i"}]},
+   nest_ltgt_r: 
+    {begin: /\</,
+     captures: {0 => {name: "punctuation.section.scope.ruby"}},
+     end: "\\>",
+     patterns: [{include: "#regex_sub"}, {include: "#nest_ltgt_r"}]},
+   nest_parens: 
+    {begin: /\(/,
+     captures: {0 => {name: "punctuation.section.scope.ruby"}},
+     end: "\\)",
+     patterns: [{include: "#nest_parens"}]},
+   nest_parens_i: 
+    {begin: /\(/,
+     captures: {0 => {name: "punctuation.section.scope.ruby"}},
+     end: "\\)",
+     patterns: 
+      [{include: "#interpolated_ruby"},
+       {include: "#escaped_char"},
+       {include: "#nest_parens_i"}]},
+   nest_parens_r: 
+    {begin: /\(/,
+     captures: {0 => {name: "punctuation.section.scope.ruby"}},
+     end: "\\)",
+     patterns: [{include: "#regex_sub"}, {include: "#nest_parens_r"}]},
+   regex_sub: 
+    {patterns: 
+      [{include: "#interpolated_ruby"},
+       {include: "#escaped_char"},
+       {captures: 
+         {1 => {name: "punctuation.definition.arbitrary-repitition.ruby"},
+          3 => {name: "punctuation.definition.arbitrary-repitition.ruby"}},
+        match: /(\{)\d+(,\d+)?(\})/,
+        name: "string.regexp.arbitrary-repitition.ruby"},
+       {begin: /\[(?:\^?\])?/,
+        captures: {0 => {name: "punctuation.definition.character-class.ruby"}},
+        end: "\\]",
+        name: "string.regexp.character-class.ruby",
+        patterns: [{include: "#escaped_char"}]},
+       {begin: /\(/,
+        captures: {0 => {name: "punctuation.definition.group.ruby"}},
+        end: "\\)",
+        name: "string.regexp.group.ruby",
+        patterns: [{include: "#regex_sub"}]},
+       {captures: {1 => {name: "punctuation.definition.comment.ruby"}},
+        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.ruby"}]}},
+ scopeName: "source.ruby",
+ uuid: "E00B62AC-6B1C-11D9-9B1F-000D93589AF6"}