feat!: drop modules, general refactor and cleanup

runtime/queries/ruby/folds.scm

@@ -0,0 +1,12 @@
+[
+  (method)
+  (singleton_method)
+  (class)
+  (module)
+  (if)
+  (else)
+  (case)
+  (do_block)
+  (singleton_class)
+  (lambda)
+] @fold

runtime/queries/ruby/highlights.scm

@@ -0,0 +1,255 @@
+; Variables
+
+(identifier) @variable
+(global_variable) @variable.global
+
+; Keywords
+
+[
+ "alias"
+ "begin"
+ "class"
+ "do"
+ "end"
+ "ensure"
+ "module"
+ "rescue"
+ "then"
+ ] @keyword
+
+[
+ "return"
+ "yield"
+] @keyword.return
+
+[
+ "and"
+ "or"
+ "in"
+ "not"
+] @keyword.operator
+
+[
+  "def"
+  "undef"
+] @keyword.function
+
+(method
+  "end" @keyword.function)
+
+[
+ "case"
+ "else"
+ "elsif"
+ "if"
+ "unless"
+ "when"
+ "then"
+ ] @conditional
+
+(if
+  "end" @conditional)
+
+[
+ "for"
+ "until"
+ "while"
+ "break"
+ "redo"
+ "retry"
+ "next"
+ ] @repeat
+
+(constant) @constant
+
+((identifier) @type.qualifier
+ (#any-of? @type.qualifier "private" "protected" "public"))
+
+[
+ "rescue"
+ "ensure"
+ ] @exception
+
+((identifier) @exception
+ (#any-of? @exception "fail" "raise"))
+
+; Function calls
+
+"defined?" @function
+
+(call
+   receiver: (constant)? @type
+   method: [
+            (identifier)
+            (constant)
+            ] @function.call
+   )
+
+(program
+ (call
+  (identifier) @include)
+ (#any-of? @include "require" "require_relative" "load"))
+
+; Function definitions
+
+(alias (identifier) @function)
+(setter (identifier) @function)
+
+(method name: [
+               (identifier) @function
+               (constant) @type
+               ])
+
+(singleton_method name: [
+                         (identifier) @function
+                         (constant) @type
+                         ])
+
+(class name: (constant) @type)
+(module name: (constant) @type)
+(superclass (constant) @type)
+
+; Identifiers
+[
+ (class_variable)
+ (instance_variable)
+ ] @label
+
+((identifier) @constant.builtin
+ (#match? @constant.builtin "^__(callee|dir|id|method|send|ENCODING|FILE|LINE)__$"))
+
+((constant) @type
+ (#not-lua-match? @type "^[A-Z0-9_]+$"))
+
+[
+ (self)
+ (super)
+ ] @variable.builtin
+
+(method_parameters (identifier) @parameter)
+(lambda_parameters (identifier) @parameter)
+(block_parameters (identifier) @parameter)
+(splat_parameter (identifier) @parameter)
+(hash_splat_parameter (identifier) @parameter)
+(optional_parameter (identifier) @parameter)
+(destructured_parameter (identifier) @parameter)
+(block_parameter (identifier) @parameter)
+(keyword_parameter (identifier) @parameter)
+
+; Literals
+
+[
+ (string)
+ (bare_string)
+ (subshell)
+ (heredoc_body)
+ ] @string
+
+[
+ (heredoc_beginning)
+ (heredoc_end)
+ ] @constant
+
+[
+ (bare_symbol)
+ (simple_symbol)
+ (delimited_symbol)
+ (hash_key_symbol)
+ ] @symbol
+
+(pair key: (hash_key_symbol) ":" @constant)
+(regex) @string.regex
+(escape_sequence) @string.escape
+(integer) @number
+(float) @float
+
+[
+ (true)
+ (false)
+ ] @boolean
+
+(nil) @constant.builtin
+
+(comment) @comment @spell
+
+(program
+  (comment)+ @comment.documentation
+  (class))
+
+(module
+  (comment)+ @comment.documentation
+  (body_statement (class)))
+
+(class
+  (comment)+ @comment.documentation
+  (body_statement (method)))
+
+(body_statement
+  (comment)+ @comment.documentation
+  (method))
+
+; Operators
+
+[
+ "!"
+ "="
+ "=="
+ "==="
+ "<=>"
+ "=>"
+ "->"
+ ">>"
+ "<<"
+ ">"
+ "<"
+ ">="
+ "<="
+ "**"
+ "*"
+ "/"
+ "%"
+ "+"
+ "-"
+ "&"
+ "|"
+ "^"
+ "&&"
+ "||"
+ "||="
+ "&&="
+ "!="
+ "%="
+ "+="
+ "-="
+ "*="
+ "/="
+ "=~"
+ "!~"
+ "?"
+ ":"
+ ".."
+ "..."
+ ] @operator
+
+[
+ ","
+ ";"
+ "."
+ ] @punctuation.delimiter
+
+[
+ "("
+ ")"
+ "["
+ "]"
+ "{"
+ "}"
+ "%w("
+ "%i("
+ ] @punctuation.bracket
+
+(interpolation
+  "#{" @punctuation.special
+  "}" @punctuation.special) @none
+
+(ERROR) @error

runtime/queries/ruby/indents.scm

@@ -0,0 +1,43 @@
+[
+  (class)
+  (singleton_class)
+  (method)
+  (singleton_method)
+  (module)
+  (call)
+  (if)
+  (block)
+  (do_block)
+  (hash)
+  (array)
+  (argument_list)
+  (case)
+  (while)
+  (until)
+  (for)
+  (begin)
+  (unless)
+  (assignment)
+  (parenthesized_statements)
+] @indent.begin
+
+[
+  "end"
+  ")"
+  "}"
+  "]"
+] @indent.end
+
+[
+  "end"
+  ")"
+  "}"
+  "]"
+  (when)
+  (elsif)
+  (else)
+  (rescue)
+  (ensure)
+] @indent.branch
+
+(comment) @indent.ignore

runtime/queries/ruby/injections.scm

@@ -0,0 +1,11 @@
+((comment) @injection.content 
+ (#set! injection.language "comment"))
+
+(heredoc_body
+ (heredoc_content) @injection.content
+ (heredoc_end) @injection.language
+ (#downcase! @injection.language))
+
+(regex 
+  (string_content) @injection.content 
+  (#set! injection.language "regex"))

runtime/queries/ruby/locals.scm

@@ -0,0 +1,55 @@
+; The MIT License (MIT)
+;
+; Copyright (c) 2016 Rob Rix
+;
+; Permission is hereby granted, free of charge, to any person obtaining a copy
+; of this software and associated documentation files (the "Software"), to deal
+; in the Software without restriction, including without limitation the rights
+; to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+; copies of the Software, and to permit persons to whom the Software is
+; furnished to do so, subject to the following conditions:
+; 
+; The above copyright notice and this permission notice shall be included in all
+; copies or substantial portions of the Software.
+; 
+; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+; IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+; FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+; AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+; LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+; SOFTWARE.
+
+;;; DECLARATIONS AND SCOPES
+(method) @scope
+(class) @scope
+
+[
+ (block)
+ (do_block) 
+ ] @scope
+
+(identifier) @reference
+(constant) @reference
+(instance_variable) @reference
+
+(module name: (constant) @definition.namespace)
+(class name: (constant) @definition.type)
+(method name: [(identifier) (constant)] @definition.function)
+(singleton_method name: [(identifier) (constant)] @definition.function)
+
+(method_parameters (identifier) @definition.var)
+(lambda_parameters (identifier) @definition.var)
+(block_parameters (identifier) @definition.var)
+(splat_parameter (identifier) @definition.var)
+(hash_splat_parameter (identifier) @definition.var)
+(optional_parameter name: (identifier) @definition.var)
+(destructured_parameter (identifier) @definition.var)
+(block_parameter name: (identifier) @definition.var)
+(keyword_parameter name: (identifier) @definition.var)
+
+(assignment left: (_) @definition.var)
+
+(left_assignment_list (identifier) @definition.var)
+(rest_assignment (identifier) @definition.var)
+(destructured_left_assignment (identifier) @definition.var)