rouge-lines 3.2.3

data/lib/rouge-lines/lexers/go.rb

@@ -0,0 +1,174 @@
+# -*- coding: utf-8 -*- #
+
+module RougeLines
+  module Lexers
+    class Go < RegexLexer
+      title "Go"
+      desc 'The Go programming language (http://golang.org)'
+      tag 'go'
+      aliases 'go', 'golang'
+      filenames '*.go'
+
+      mimetypes 'text/x-go', 'application/x-go'
+
+      # Characters
+
+      WHITE_SPACE            = /[\s\t\r\n]+/
+
+      NEWLINE                = /\n/
+      UNICODE_CHAR           = /[^\n]/
+      UNICODE_LETTER         = /[[:alpha:]]/
+      UNICODE_DIGIT          = /[[:digit:]]/
+
+      # Letters and digits
+
+      LETTER                 = /#{UNICODE_LETTER}|_/
+      DECIMAL_DIGIT          = /[0-9]/
+      OCTAL_DIGIT            = /[0-7]/
+      HEX_DIGIT              = /[0-9A-Fa-f]/
+
+      # Comments
+
+      LINE_COMMENT           = /\/\/(?:(?!#{NEWLINE}).)*/
+      GENERAL_COMMENT        = /\/\*(?:(?!\*\/).)*\*\//m
+      COMMENT                = /#{LINE_COMMENT}|#{GENERAL_COMMENT}/
+
+      # Keywords
+
+      KEYWORD                = /\b(?:
+                                 break       | default     | func
+                               | interface   | select      | case
+                               | defer       | go          | map
+                               | struct      | chan        | else
+                               | goto        | package     | switch
+                               | const       | fallthrough | if
+                               | range       | type        | continue
+                               | for         | import      | return
+                               | var
+                               )\b/x
+
+      # Identifiers
+
+      IDENTIFIER             = / (?!#{KEYWORD})
+                                 #{LETTER}(?:#{LETTER}|#{UNICODE_DIGIT})* /x
+
+      # Operators and delimiters
+
+      OPERATOR               = / \+=    | \+\+   | \+     | &\^=   | &\^
+                               | &=     | &&     | &      | ==     | =
+                               | \!=    | \!     | -=     | --     | -
+                               | \|=    | \|\|   | \|     | <=     | <-
+                               | <<=    | <<     | <      | \*=    | \*
+                               | \^=    | \^     | >>=    | >>     | >=
+                               | >      | \/     | \/=    | :=     | %
+                               | %=     | \.\.\. | \.     | :
+                               /x
+
+      SEPARATOR              = / \(     | \)     | \[     | \]     | \{
+                               | \}     | ,      | ;
+                               /x
+
+      # Integer literals
+
+      DECIMAL_LIT            = /[0-9]#{DECIMAL_DIGIT}*/
+      OCTAL_LIT              = /0#{OCTAL_DIGIT}*/
+      HEX_LIT                = /0[xX]#{HEX_DIGIT}+/
+      INT_LIT                = /#{HEX_LIT}|#{DECIMAL_LIT}|#{OCTAL_LIT}/
+
+      # Floating-point literals
+
+      DECIMALS               = /#{DECIMAL_DIGIT}+/
+      EXPONENT               = /[eE][+\-]?#{DECIMALS}/
+      FLOAT_LIT              = / #{DECIMALS} \. #{DECIMALS}? #{EXPONENT}?
+                               | #{DECIMALS} #{EXPONENT}
+                               | \. #{DECIMALS} #{EXPONENT}?
+                               /x
+
+      # Imaginary literals
+
+      IMAGINARY_LIT          = /(?:#{DECIMALS}|#{FLOAT_LIT})i/
+
+      # Rune literals
+
+      ESCAPED_CHAR           = /\\[abfnrtv\\'"]/
+      LITTLE_U_VALUE         = /\\u#{HEX_DIGIT}{4}/
+      BIG_U_VALUE            = /\\U#{HEX_DIGIT}{8}/
+      UNICODE_VALUE          = / #{UNICODE_CHAR} | #{LITTLE_U_VALUE}
+                               | #{BIG_U_VALUE}  | #{ESCAPED_CHAR}
+                               /x
+      OCTAL_BYTE_VALUE       = /\\#{OCTAL_DIGIT}{3}/
+      HEX_BYTE_VALUE         = /\\x#{HEX_DIGIT}{2}/
+      BYTE_VALUE             = /#{OCTAL_BYTE_VALUE}|#{HEX_BYTE_VALUE}/
+      CHAR_LIT               = /'(?:#{UNICODE_VALUE}|#{BYTE_VALUE})'/
+      ESCAPE_SEQUENCE        = / #{ESCAPED_CHAR}
+                               | #{LITTLE_U_VALUE}
+                               | #{BIG_U_VALUE}
+                               | #{HEX_BYTE_VALUE}
+                               /x
+
+      # String literals
+
+      RAW_STRING_LIT         = /`(?:#{UNICODE_CHAR}|#{NEWLINE})*`/
+      INTERPRETED_STRING_LIT = / "(?: (?!")
+                                      (?: #{UNICODE_VALUE} | #{BYTE_VALUE} )
+                                  )*" /x
+      STRING_LIT             = /#{RAW_STRING_LIT}|#{INTERPRETED_STRING_LIT}/
+
+      # Predeclared identifiers
+
+      PREDECLARED_TYPES      = /\b(?:
+                                 bool       | byte       | complex64
+                               | complex128 | error      | float32
+                               | float64    | int8       | int16
+                               | int32      | int64      | int
+                               | rune       | string     | uint8
+                               | uint16     | uint32     | uint64
+                               | uintptr    | uint
+      	                       )\b/x
+
+      PREDECLARED_CONSTANTS  = /\b(?:true|false|iota|nil)\b/
+
+      PREDECLARED_FUNCTIONS  = /\b(?:
+                                 append  | cap     | close   | complex
+                               | copy    | delete  | imag    | len
+                               | make    | new     | panic   | print
+                               | println | real    | recover
+                               )\b/x
+
+      state :simple_tokens do
+        rule(COMMENT,               Comment)
+        rule(KEYWORD,               Keyword)
+        rule(PREDECLARED_TYPES,     Keyword::Type)
+        rule(PREDECLARED_FUNCTIONS, Name::Builtin)
+        rule(PREDECLARED_CONSTANTS, Name::Constant)
+        rule(IMAGINARY_LIT,         Num)
+        rule(FLOAT_LIT,             Num)
+        rule(INT_LIT,               Num)
+        rule(CHAR_LIT,              Str::Char)
+        rule(OPERATOR,              Operator)
+        rule(SEPARATOR,             Punctuation)
+        rule(IDENTIFIER,            Name)
+        rule(WHITE_SPACE,           Other)
+      end
+
+      state :root do
+        mixin :simple_tokens
+
+        rule(/`/,             Str, :raw_string)
+        rule(/"/,             Str, :interpreted_string)
+      end
+
+      state :interpreted_string do
+        rule(ESCAPE_SEQUENCE, Str::Escape)
+        rule(/\\./,           Error)
+        rule(/"/,             Str, :pop!)
+        rule(/[^"\\]+/,       Str)
+      end
+
+      state :raw_string do
+        rule(/`/,             Str, :pop!)
+        rule(/[^`]+/m,        Str)
+      end
+    end
+  end
+end

data/lib/rouge-lines/lexers/gradle.rb

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*- #
+
+module RougeLines
+  module Lexers
+    load_lexer 'groovy.rb'
+
+    class Gradle < Groovy
+      title "Gradle"
+      desc "A powerful build system for the JVM"
+
+      tag 'gradle'
+      filenames '*.gradle'
+      mimetypes 'text/x-gradle'
+
+      def self.keywords
+        @keywords ||= super + Set.new(%w(
+          allprojects artifacts buildscript configuration dependencies
+          repositories sourceSets subprojects publishing
+        ))
+      end
+
+      def self.types
+        @types ||= super + Set.new(%w(
+          Project Task Gradle Settings Script JavaToolChain SourceSet
+          SourceSetOutput IncrementalTaskInputs Configuration
+          ResolutionStrategy ArtifactResolutionQuery ComponentSelection
+          ComponentSelectionRules ConventionProperty ExtensionAware
+          ExtraPropertiesExtension PublishingExtension IvyPublication
+          IvyArtifact IvyArtifactSet IvyModuleDescriptorSpec
+          MavenPublication MavenArtifact MavenArtifactSet MavenPom
+          PluginDependenciesSpec PluginDependencySpec ResourceHandler
+          TextResourceFactory
+        ))
+      end
+    end
+  end
+end

data/lib/rouge-lines/lexers/graphql.rb

@@ -0,0 +1,243 @@
+# -*- coding: utf-8 -*- #
+
+module RougeLines
+  module Lexers
+    class GraphQL < RegexLexer
+      desc 'GraphQL'
+      tag 'graphql'
+      filenames '*.graphql', '*.gql'
+      mimetypes 'application/graphql'
+
+      name = /[_A-Za-z][_0-9A-Za-z]*/
+
+      state :root do
+        rule /\b(?:query|mutation|subscription)\b/, Keyword, :query_definition
+        rule /\{/ do
+          token Punctuation
+          push :query_definition
+          push :selection_set
+        end
+
+        rule /\bfragment\b/, Keyword, :fragment_definition
+
+        rule /\b(?:type|interface|enum)\b/, Keyword, :type_definition
+        rule /\b(?:input|schema)\b/, Keyword, :type_definition
+
+        rule /\bunion\b/, Keyword, :union_definition
+
+        mixin :basic
+      end
+
+      state :basic do
+        rule /\s+/m, Text::Whitespace
+        rule /#.*$/, Comment
+
+        rule /[!,]/, Punctuation
+      end
+
+      state :has_directives do
+        rule /(@#{name})(\s*)(\()/ do
+          groups Keyword, Text::Whitespace, Punctuation
+          push :arguments
+        end
+        rule /@#{name}\b/, Keyword
+      end
+
+      state :fragment_definition do
+        rule /\bon\b/, Keyword
+
+        mixin :query_definition
+      end
+
+      state :query_definition do
+        mixin :has_directives
+
+        rule /\b#{name}\b/, Name
+        rule /\(/, Punctuation, :variable_definitions
+        rule /\{/, Punctuation, :selection_set
+
+        mixin :basic
+      end
+
+      state :type_definition do
+        rule /\bimplements\b/, Keyword
+        rule /\b#{name}\b/, Name
+        rule /\(/, Punctuation, :variable_definitions
+        rule /\{/, Punctuation, :type_definition_set
+
+        mixin :basic
+      end
+
+      state :union_definition do
+        rule /\b#{name}\b/, Name
+        rule /\=/, Punctuation, :union_definition_variant
+
+        mixin :basic
+      end
+
+      state :union_definition_variant do
+        rule /\b#{name}\b/ do
+          token Name
+          pop!
+          push :union_definition_pipe
+        end
+
+        mixin :basic
+      end
+
+      state :union_definition_pipe do
+        rule /\|/ do
+          token Punctuation
+          pop!
+          push :union_definition_variant
+        end
+
+        rule /(?!\||\s+|#[^\n]*)/ do
+          pop! 2
+        end
+
+        mixin :basic
+      end
+
+      state :type_definition_set do
+        rule /\}/ do
+          token Punctuation
+          pop! 2
+        end
+
+        rule /\b(#{name})(\s*)(\()/ do
+          groups Name, Text::Whitespace, Punctuation
+          push :variable_definitions
+        end
+        rule /\b#{name}\b/, Name
+
+        rule /:/, Punctuation, :type_names
+
+        mixin :basic
+      end
+
+      state :arguments do
+        rule /\)/ do
+          token Punctuation
+          pop!
+        end
+
+        rule /\b#{name}\b/, Name
+        rule /:/, Punctuation, :value
+
+        mixin :basic
+      end
+
+      state :variable_definitions do
+        rule /\)/ do
+          token Punctuation
+          pop!
+        end
+
+        rule /\$#{name}\b/, Name::Variable
+        rule /\b#{name}\b/, Name
+        rule /:/, Punctuation, :type_names
+        rule /\=/, Punctuation, :value
+
+        mixin :basic
+      end
+
+      state :type_names do
+        rule /\b(?:Int|Float|String|Boolean|ID)\b/, Name::Builtin, :pop!
+        rule /\b#{name}\b/, Name, :pop!
+
+        rule /\[/, Punctuation, :type_name_list
+
+        mixin :basic
+      end
+
+      state :type_name_list do
+        rule /\b(?:Int|Float|String|Boolean|ID)\b/, Name::Builtin
+        rule /\b#{name}\b/, Name
+
+        rule /\]/ do
+          token Punctuation
+          pop! 2
+        end
+
+        mixin :basic
+      end
+
+      state :selection_set do
+        mixin :has_directives
+
+        rule /\}/ do
+          token Punctuation
+          pop!
+          pop! if state?(:query_definition) || state?(:fragment_definition)
+        end
+
+        rule /\b(#{name})(\s*)(\()/ do
+          groups Name, Text::Whitespace, Punctuation
+          push :arguments
+        end
+
+        rule /\b(#{name})(\s*)(:)/ do
+          groups Name, Text::Whitespace, Punctuation
+        end
+
+        rule /\b#{name}\b/, Name
+
+        rule /(\.\.\.)(\s+)(on)\b/ do
+          groups Punctuation, Text::Whitespace, Keyword
+        end
+        rule /\.\.\./, Punctuation
+
+        rule /\{/, Punctuation, :selection_set
+
+        mixin :basic
+      end
+
+      state :list do
+        rule /\]/ do
+          token Punctuation
+          pop!
+          pop! if state?(:value)
+        end
+
+        mixin :value
+      end
+
+      state :object do
+        rule /\}/ do
+          token Punctuation
+          pop!
+          pop! if state?(:value)
+        end
+
+        rule /\b(#{name})(\s*)(:)/ do
+          groups Name, Text::Whitespace, Punctuation
+          push :value
+        end
+
+        mixin :basic
+      end
+
+      state :value do
+        pop_unless_list = ->(t) {
+          ->(m) {
+            token t
+            pop! unless state?(:list)
+          }
+        }
+
+        rule /\$#{name}\b/, &pop_unless_list[Name::Variable]
+        rule /\b(?:true|false|null)\b/, &pop_unless_list[Keyword::Constant]
+        rule /[+-]?[0-9]+\.[0-9]+(?:[eE][+-]?[0-9]+)?/, &pop_unless_list[Num::Float]
+        rule /[+-]?[1-9][0-9]*(?:[eE][+-]?[0-9]+)?/, &pop_unless_list[Num::Integer]
+        rule /"(\\[\\"]|[^"])*"/, &pop_unless_list[Str::Double]
+        rule /\b#{name}\b/, &pop_unless_list[Name]
+
+        rule /\{/, Punctuation, :object
+        rule /\[/, Punctuation, :list
+
+        mixin :basic
+      end
+    end
+  end
+end