rouge 3.17.0

data/lib/rouge/lexers/gradle.rb

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  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/lexers/graphql.rb

@@ -0,0 +1,261 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  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 %r/\b(?:query|mutation|subscription)\b/, Keyword, :query_definition
+        rule %r/\{/ do
+          token Punctuation
+          push :query_definition
+          push :selection_set
+        end
+
+        rule %r/\bfragment\b/, Keyword, :fragment_definition
+        
+        rule %r/\bscalar\b/, Keyword, :value
+
+        rule %r/\b(?:type|interface|enum)\b/, Keyword, :type_definition
+
+        rule %r/\b(?:input|schema)\b/, Keyword, :type_definition
+
+        rule %r/\bunion\b/, Keyword, :union_definition
+
+        rule %r/\bextend\b/, Keyword
+
+        mixin :basic
+
+        # Markdown descriptions
+        rule %r/(""")(\n)(.*?)(\n)(""")/m do |m|
+          token Str::Double, m[1]
+          token Text::Whitespace, m[2]
+          delegate Markdown, m[3]
+          token Text::Whitespace, m[4]
+          token Str::Double, m[5]
+        end
+      end
+
+      state :basic do
+        rule %r/\s+/m, Text::Whitespace
+        rule %r/#.*$/, Comment
+
+        rule %r/[!,]/, Punctuation
+      end
+
+      state :has_directives do
+        rule %r/(@#{name})(\s*)(\()/ do
+          groups Keyword, Text::Whitespace, Punctuation
+          push :arguments
+        end
+        rule %r/@#{name}\b/, Keyword
+      end
+
+      state :fragment_definition do
+        rule %r/\bon\b/, Keyword
+
+        mixin :query_definition
+      end
+
+      state :query_definition do
+        mixin :has_directives
+
+        rule %r/\b#{name}\b/, Name
+        rule %r/\(/, Punctuation, :variable_definitions
+        rule %r/\{/, Punctuation, :selection_set
+
+        mixin :basic
+      end
+
+      state :type_definition do
+        rule %r/\bimplements\b/, Keyword
+        rule %r/\b#{name}\b/, Name
+        rule %r/\(/, Punctuation, :variable_definitions
+        rule %r/\{/, Punctuation, :type_definition_set
+
+        mixin :basic
+      end
+
+      state :union_definition do
+        rule %r/\b#{name}\b/, Name
+        rule %r/\=/, Punctuation, :union_definition_variant
+
+        mixin :basic
+      end
+
+      state :union_definition_variant do
+        rule %r/\b#{name}\b/ do
+          token Name
+          pop!
+          push :union_definition_pipe
+        end
+
+        mixin :basic
+      end
+
+      state :union_definition_pipe do
+        rule %r/\|/ do
+          token Punctuation
+          pop!
+          push :union_definition_variant
+        end
+
+        rule %r/(?!\||\s+|#[^\n]*)/ do
+          pop! 2
+        end
+
+        mixin :basic
+      end
+
+      state :type_definition_set do
+        rule %r/\}/ do
+          token Punctuation
+          pop! 2
+        end
+
+        rule %r/\b(#{name})(\s*)(\()/ do
+          groups Name, Text::Whitespace, Punctuation
+          push :variable_definitions
+        end
+        rule %r/\b#{name}\b/, Name
+
+        rule %r/:/, Punctuation, :type_names
+
+        mixin :basic
+      end
+
+      state :arguments do
+        rule %r/\)/ do
+          token Punctuation
+          pop!
+        end
+
+        rule %r/\b#{name}\b/, Name
+        rule %r/:/, Punctuation, :value
+
+        mixin :basic
+      end
+
+      state :variable_definitions do
+        rule %r/\)/ do
+          token Punctuation
+          pop!
+        end
+
+        rule %r/\$#{name}\b/, Name::Variable
+        rule %r/\b#{name}\b/, Name
+        rule %r/:/, Punctuation, :type_names
+        rule %r/\=/, Punctuation, :value
+
+        mixin :basic
+      end
+
+      state :type_names do
+        rule %r/\b(?:Int|Float|String|Boolean|ID)\b/, Name::Builtin, :pop!
+        rule %r/\b#{name}\b/, Name, :pop!
+
+        rule %r/\[/, Punctuation, :type_name_list
+
+        mixin :basic
+      end
+
+      state :type_name_list do
+        rule %r/\b(?:Int|Float|String|Boolean|ID)\b/, Name::Builtin
+        rule %r/\b#{name}\b/, Name
+
+        rule %r/\]/ do
+          token Punctuation
+          pop! 2
+        end
+
+        mixin :basic
+      end
+
+      state :selection_set do
+        mixin :has_directives
+
+        rule %r/\}/ do
+          token Punctuation
+          pop!
+          pop! if state?(:query_definition) || state?(:fragment_definition)
+        end
+
+        rule %r/\b(#{name})(\s*)(\()/ do
+          groups Name, Text::Whitespace, Punctuation
+          push :arguments
+        end
+
+        rule %r/\b(#{name})(\s*)(:)/ do
+          groups Name, Text::Whitespace, Punctuation
+        end
+
+        rule %r/\b#{name}\b/, Name
+
+        rule %r/(\.\.\.)(\s+)(on)\b/ do
+          groups Punctuation, Text::Whitespace, Keyword
+        end
+        rule %r/\.\.\./, Punctuation
+
+        rule %r/\{/, Punctuation, :selection_set
+
+        mixin :basic
+      end
+
+      state :list do
+        rule %r/\]/ do
+          token Punctuation
+          pop!
+          pop! if state?(:value)
+        end
+
+        mixin :value
+      end
+
+      state :object do
+        rule %r/\}/ do
+          token Punctuation
+          pop!
+          pop! if state?(:value)
+        end
+
+        rule %r/\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)
+          }
+        }
+
+        # Multiline strings
+        rule %r/""".*?"""/m, Str::Double
+
+        rule %r/\$#{name}\b/, &pop_unless_list[Name::Variable]
+        rule %r/\b(?:true|false|null)\b/, &pop_unless_list[Keyword::Constant]
+        rule %r/[+-]?[0-9]+\.[0-9]+(?:[eE][+-]?[0-9]+)?/, &pop_unless_list[Num::Float]
+        rule %r/[+-]?[1-9][0-9]*(?:[eE][+-]?[0-9]+)?/, &pop_unless_list[Num::Integer]
+        rule %r/"(\\[\\"]|[^"])*"/, &pop_unless_list[Str::Double]
+        rule %r/\b#{name}\b/, &pop_unless_list[Name]
+
+        rule %r/\{/, Punctuation, :object
+        rule %r/\[/, Punctuation, :list
+
+        mixin :basic
+      end
+    end
+  end
+end

data/lib/rouge/lexers/groovy.rb

@@ -0,0 +1,111 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Groovy < RegexLexer
+      title "Groovy"
+      desc 'The Groovy programming language (http://www.groovy-lang.org/)'
+      tag 'groovy'
+      filenames '*.groovy', 'Jenkinsfile'
+      mimetypes 'text/x-groovy'
+
+      def self.detect?(text)
+        return true if text.shebang?(/groovy/)
+      end
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          assert break case catch continue default do else finally for
+          if goto instanceof new return switch this throw try while in as
+        )
+      end
+
+      def self.declarations
+        @declarations ||= Set.new %w(
+          abstract const enum extends final implements native private
+          protected public static strictfp super synchronized throws
+          transient volatile
+        )
+      end
+
+      def self.types
+        @types ||= Set.new %w(
+          def boolean byte char double float int long short void
+        )
+      end
+
+      def self.constants
+        @constants ||= Set.new %w(true false null)
+      end
+
+      state :root do
+        rule %r(^
+          (\s*(?:\w[\w.\[\]]*\s+)+?) # return arguments
+          (\w\w*) # method name
+          (\s*) (\() # signature start
+        )x do |m|
+          delegate self.clone, m[1]
+          token Name::Function, m[2]
+          token Text, m[3]
+          token Operator, m[4]
+        end
+
+        # whitespace
+        rule %r/[^\S\n]+/, Text
+        rule %r(//.*?$), Comment::Single
+        rule %r(/[*].*?[*]/)m, Comment::Multiline
+        rule %r/@\w[\w.]*/, Name::Decorator
+        rule %r/(class|interface|trait)\b/,  Keyword::Declaration, :class
+        rule %r/package\b/, Keyword::Namespace, :import
+        rule %r/import\b/, Keyword::Namespace, :import
+
+        # TODO: highlight backslash escapes
+        rule %r/""".*?"""/m, Str::Double
+        rule %r/'''.*?'''/m, Str::Single
+
+        rule %r/"(\\.|\\\n|.)*?"/, Str::Double
+        rule %r/'(\\.|\\\n|.)*?'/, Str::Single
+        rule %r(\$/(\$.|.)*?/\$)m, Str
+        rule %r(/(\\.|\\\n|.)*?/), Str
+        rule %r/'\\.'|'[^\\]'|'\\u[0-9a-f]{4}'/, Str::Char
+        rule %r/(\.)([a-zA-Z_][a-zA-Z0-9_]*)/ do
+          groups Operator, Name::Attribute
+        end
+
+        rule %r/[a-zA-Z_][a-zA-Z0-9_]*:/, Name::Label
+        rule %r/[a-zA-Z_\$][a-zA-Z0-9_]*/ do |m|
+          if self.class.keywords.include? m[0]
+            token Keyword
+          elsif self.class.declarations.include? m[0]
+            token Keyword::Declaration
+          elsif self.class.types.include? m[0]
+            token Keyword::Type
+          elsif self.class.constants.include? m[0]
+            token Keyword::Constant
+          else
+            token Name
+          end
+        end
+
+        rule %r([~^*!%&\[\](){}<>\|+=:;,./?-]), Operator
+
+        # numbers
+        rule %r/\d+\.\d+([eE]\d+)?[fd]?/, Num::Float
+        rule %r/0x[0-9a-f]+/, Num::Hex
+        rule %r/[0-9]+L?/, Num::Integer
+        rule %r/\n/, Text
+      end
+
+      state :class do
+        rule %r/\s+/, Text
+        rule %r/\w\w*/, Name::Class, :pop!
+      end
+
+      state :import do
+        rule %r/\s+/, Text
+        rule %r/[\w.]+[*]?/, Name::Namespace, :pop!
+      end
+    end
+  end
+end

data/lib/rouge/lexers/hack.rb

@@ -0,0 +1,49 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    load_lexer 'php.rb'
+
+    class Hack < PHP
+      title 'Hack'
+      desc 'The Hack programming language (hacklang.org)'
+      tag 'hack'
+      aliases 'hack', 'hh'
+      filenames '*.php', '*.hh'
+
+      def self.detect?(text)
+        return true if /<\?hh/ =~ text
+        return true if text.shebang?('hhvm')
+        return true if /async function [a-zA-Z]/ =~ text
+        return true if /\): Awaitable</ =~ text
+
+        return false
+      end
+
+      def self.keywords
+        @hh_keywords ||= super.merge Set.new %w(
+          type newtype enum
+          as super
+          async await Awaitable
+          vec dict keyset
+          void int string bool float double
+          arraykey num Stringish
+        )
+      end
+
+      prepend :template do
+        rule %r/<\?hh(\s*\/\/\s*(strict|decl|partial))?$/, Comment::Preproc, :php
+      end
+
+      prepend :php do
+        rule %r((/\*\s*)(HH_(?:IGNORE_ERROR|FIXME)\[\d+\])([^*]*)(\*/)) do
+          groups Comment::Preproc, Comment::Preproc, Comment::Multiline, Comment::Preproc
+        end
+
+        rule %r(// UNSAFE(?:_EXPR|_BLOCK)?), Comment::Preproc
+        rule %r(/\*\s*UNSAFE_EXPR\s*\*/), Comment::Preproc
+      end
+    end
+  end
+end