rouge-alda 3.3.0

data/lib/rouge/lexers/graphql.rb

@@ -0,0 +1,254 @@
+# -*- 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 /\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
+
+        # Markdown descriptions
+        rule /(""")(.*?)(""")/m do |m|
+          token Str::Double, m[1]
+          delegate Markdown, m[2]
+          token Str::Double, m[3]
+        end
+      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)
+          }
+        }
+
+        # Multiline strings
+        rule /""".*?"""/m, Str::Double
+
+        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

data/lib/rouge/lexers/groovy.rb

@@ -0,0 +1,113 @@
+# -*- 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'
+
+      ws = %r((?:\s|//.*?\n|/[*].*?[*]/)+)
+
+      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\d.\[\]]*\s+)+?) # return arguments
+          (\w[\w\d]*) # 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 /[^\S\n]+/, Text
+        rule %r(//.*?$), Comment::Single
+        rule %r(/[*].*?[*]/)m, Comment::Multiline
+        rule /@\w[\w\d.]*/, Name::Decorator
+        rule /(class|interface|trait)\b/,  Keyword::Declaration, :class
+        rule /package\b/, Keyword::Namespace, :import
+        rule /import\b/, Keyword::Namespace, :import
+
+        # TODO: highlight backslash escapes
+        rule /""".*?"""/m, Str::Double
+        rule /'''.*?'''/m, Str::Single
+
+        rule /"(\\.|\\\n|.)*?"/, Str::Double
+        rule /'(\\.|\\\n|.)*?'/, Str::Single
+        rule %r(\$/(\$.|.)*?/\$)m, Str
+        rule %r(/(\\.|\\\n|.)*?/), Str
+        rule /'\\.'|'[^\\]'|'\\u[0-9a-f]{4}'/, Str::Char
+        rule /(\.)([a-zA-Z_][a-zA-Z0-9_]*)/ do
+          groups Operator, Name::Attribute
+        end
+
+        rule /[a-zA-Z_][a-zA-Z0-9_]*:/, Name::Label
+        rule /[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 /\d+\.\d+([eE]\d+)?[fd]?/, Num::Float
+        rule /0x[0-9a-f]+/, Num::Hex
+        rule /[0-9]+L?/, Num::Integer
+        rule /\n/, Text
+      end
+
+      state :class do
+        rule /\s+/, Text
+        rule /\w[\w\d]*/, Name::Class, :pop!
+      end
+
+      state :import do
+        rule /\s+/, Text
+        rule /[\w\d.]+[*]?/, 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 /<\?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

data/lib/rouge/lexers/haml.rb

@@ -0,0 +1,230 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    # A lexer for the Haml templating system for Ruby.
+    # @see http://haml.info
+    class Haml < RegexLexer
+      include Indentation
+
+      title "Haml"
+      desc "The Haml templating system for Ruby (haml.info)"
+
+      tag 'haml'
+      aliases 'HAML'
+
+      filenames '*.haml'
+      mimetypes 'text/x-haml'
+
+      option 'filters[filter_name]', 'Mapping of lexers to use for haml :filters'
+      attr_reader :filters
+      # @option opts :filters
+      #   A hash of filter name to lexer of how various filters should be
+      #   highlighted.  By default, :javascript, :css, :ruby, and :erb
+      #   are supported.
+      def initialize(opts={})
+        super
+
+        default_filters = {
+          'javascript' => Javascript.new(options),
+          'css' => CSS.new(options),
+          'ruby' => ruby,
+          'erb' => ERB.new(options),
+          'markdown' => Markdown.new(options),
+          'sass' => Sass.new(options),
+          # TODO
+          # 'textile' => Textile.new(options),
+          # 'maruku' => Maruku.new(options),
+        }
+
+        @filters = hash_option(:filters, default_filters) do |v|
+          as_lexer(v) || PlainText.new(@options)
+        end
+      end
+
+      def ruby
+        @ruby ||= Ruby.new(@options)
+      end
+
+      def html
+        @html ||= HTML.new(@options)
+      end
+
+      def ruby!(state)
+        ruby.reset!
+        push state
+      end
+
+      start { ruby.reset!; html.reset! }
+
+      identifier = /[\w:-]+/
+      ruby_var = /[a-z]\w*/
+
+      # Haml can include " |\n" anywhere,
+      # which is ignored and used to wrap long lines.
+      # To accomodate this, use this custom faux dot instead.
+      dot = /[ ]\|\n(?=.*[ ]\|)|./
+
+      # In certain places, a comma at the end of the line
+      # allows line wrapping as well.
+      comma_dot = /,\s*\n|#{dot}/
+
+      state :root do
+        rule /\s*\n/, Text
+        rule(/\s*/) { |m| token Text; indentation(m[0]) }
+      end
+
+      state :content do
+        mixin :css
+        rule(/%#{identifier}/) { token Name::Tag; goto :tag }
+        rule /!!!#{dot}*\n/, Name::Namespace, :pop!
+        rule %r(
+          (/) (\[#{dot}*?\]) (#{dot}*\n)
+        )x do
+          groups Comment, Comment::Special, Comment
+          pop!
+        end
+
+        rule %r(/#{dot}*\n) do
+          token Comment
+          pop!
+          starts_block :html_comment_block
+        end
+
+        rule /-##{dot}*\n/ do
+          token Comment
+          pop!
+          starts_block :haml_comment_block
+        end
+
+        rule /-/ do
+          token Punctuation
+          reset_stack
+          ruby! :ruby_line
+        end
+
+        # filters
+        rule /:(#{dot}*)\n/ do |m|
+          token Name::Decorator
+          pop!
+          starts_block :filter_block
+
+          filter_name = m[1].strip
+
+          @filter_lexer = self.filters[filter_name]
+          @filter_lexer.reset! unless @filter_lexer.nil?
+
+          puts "    haml: filter #{filter_name.inspect} #{@filter_lexer.inspect}" if @debug
+        end
+
+        mixin :eval_or_plain
+      end
+
+      state :css do
+        rule(/\.#{identifier}/) { token Name::Class; goto :tag }
+        rule(/##{identifier}/) { token Name::Function; goto :tag }
+      end
+
+      state :tag do
+        mixin :css
+        rule(/[{]/) { token Punctuation; ruby! :ruby_tag }
+        rule(/\[#{dot}*?\]/) { delegate ruby }
+
+        rule /\(/, Punctuation, :html_attributes
+        rule /\s*\n/, Text, :pop!
+
+        # whitespace chompers
+        rule /[<>]{1,2}(?=[ \t=])/, Punctuation
+
+        mixin :eval_or_plain
+      end
+
+      state :plain do
+        rule(/([^#\n]|#[^{\n]|(\\\\)*\\#\{)+/) { delegate html }
+        mixin :interpolation
+        rule(/\n/) { token Text; reset_stack }
+      end
+
+      state :eval_or_plain do
+        rule /[&!]?==/, Punctuation, :plain
+        rule /[&!]?[=!]/ do
+          token Punctuation
+          reset_stack
+          ruby! :ruby_line
+        end
+
+        rule(//) { push :plain }
+      end
+
+      state :ruby_line do
+        rule /\n/, Text, :pop!
+        rule(/,[ \t]*\n/) { delegate ruby }
+        rule /[ ]\|[ \t]*\n/, Str::Escape
+        rule(/.*?(?=(,$| \|)?[ \t]*$)/) { delegate ruby }
+      end
+
+      state :ruby_tag do
+        mixin :ruby_inner
+      end
+
+      state :html_attributes do
+        rule /\s+/, Text
+        rule /#{identifier}\s*=/, Name::Attribute, :html_attribute_value
+        rule identifier, Name::Attribute
+        rule /\)/, Text, :pop!
+      end
+
+      state :html_attribute_value do
+        rule /\s+/, Text
+        rule ruby_var, Name::Variable, :pop!
+        rule /@#{ruby_var}/, Name::Variable::Instance, :pop!
+        rule /\$#{ruby_var}/, Name::Variable::Global, :pop!
+        rule /'(\\\\|\\'|[^'\n])*'/, Str, :pop!
+        rule /"(\\\\|\\"|[^"\n])*"/, Str, :pop!
+      end
+
+      state :html_comment_block do
+        rule /#{dot}+/, Comment
+        mixin :indented_block
+      end
+
+      state :haml_comment_block do
+        rule /#{dot}+/, Comment::Preproc
+        mixin :indented_block
+      end
+
+      state :filter_block do
+        rule /([^#\n]|#[^{\n]|(\\\\)*\\#\{)+/ do
+          if @filter_lexer
+            delegate @filter_lexer
+          else
+            token Name::Decorator
+          end
+        end
+
+        mixin :interpolation
+        mixin :indented_block
+      end
+
+      state :interpolation do
+        rule /#[{]/, Str::Interpol, :ruby
+      end
+
+      state :ruby do
+        rule /[}]/, Str::Interpol, :pop!
+        mixin :ruby_inner
+      end
+
+      state :ruby_inner do
+        rule(/[{]/) { delegate ruby; push :ruby_inner }
+        rule(/[}]/) { delegate ruby; pop! }
+        rule(/[^{}]+/) { delegate ruby }
+      end
+
+      state :indented_block do
+        rule(/\n/) { token Text; reset_stack }
+      end
+    end
+  end
+end