rouge 3.17.0

data/lib/rouge/lexers/liquid.rb

@@ -0,0 +1,285 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Liquid < RegexLexer
+      title "Liquid"
+      desc 'Liquid is a templating engine for Ruby (liquidmarkup.org)'
+      tag 'liquid'
+      filenames '*.liquid'
+
+      state :root do
+        rule %r/[^\{]+/, Text
+
+        rule %r/(\{%-?)(\s*)/ do
+          groups Punctuation, Text::Whitespace
+          push :tag_or_block
+        end
+
+        rule %r/(\{\{-?)(\s*)/ do
+          groups Punctuation, Text::Whitespace
+          push :output
+        end
+
+        rule %r/\{/, Text
+      end
+
+      state :tag_or_block do
+        # builtin logic blocks
+        rule %r/(if|elsif|unless|case)\b/, Keyword::Reserved, :condition
+        rule %r/(when)\b/, Keyword::Reserved, :when
+
+        rule %r/(else)(\s*)(-?%\})/ do
+          groups Keyword::Reserved, Text::Whitespace, Punctuation
+          pop!
+        end
+
+        # other builtin blocks
+        rule %r/(capture|(?:in|de)crement)(\s+)([^\s%]+)(\s*)(-?%\})/ do
+          groups Name::Tag, Text::Whitespace, Name::Variable, Text::Whitespace, Punctuation
+          pop!
+        end
+
+        rule %r/(comment)(\s*)(-?%\})/ do
+          groups Name::Tag, Text::Whitespace, Punctuation
+          push :comment
+        end
+
+        rule %r/(raw)(\s*)(-?%\})/ do
+          groups Name::Tag, Text::Whitespace, Punctuation
+          push :raw
+        end
+
+        # end of block
+        rule %r/(end(?:if|unless|case))(\s*)(-?%\})/ do
+          groups Keyword::Reserved, Text::Whitespace, Punctuation
+          pop!
+        end
+
+        rule %r/(end(?:[^\s%]+))(\s*)(-?%\})/ do
+          groups Name::Tag, Text::Whitespace, Punctuation
+          pop!
+        end
+
+        # builtin tags
+        rule %r/(assign|echo)\b/, Name::Tag, :assign
+        rule %r/(include|render)\b/, Name::Tag, :include
+
+        rule %r/(cycle)(\s+)(?:([^\s:]*)(\s*)(:))?(\s*)/ do |m|
+          token_class = case m[3]
+                        when %r/'[^']*'/ then Str::Single
+                        when %r/"[^"]*"/ then Str::Double
+                        else
+                          Name::Attribute
+                        end
+
+          groups Name::Tag, Text::Whitespace, token_class,
+                 Text::Whitespace, Punctuation, Text::Whitespace
+
+          push :variable_tag_markup
+        end
+
+        # iteration
+        rule %r/
+          (for|tablerow)(\s+)
+          ([\w-]+)(\s+)
+          (in)(\s+)
+          (
+            (?: [^\s%,\|'"] | (?:"[^"]*"|'[^']*') )+
+          )(\s*)
+        /x do |m|
+          groups Name::Tag, Text::Whitespace, Name::Variable, Text::Whitespace,
+                 Name::Tag, Text::Whitespace
+
+          token_class = case m[7]
+                        when %r/'[^']*'/ then Str::Single
+                        when %r/"[^"]*"/ then Str::Double
+                        else
+                          Name::Variable
+                        end
+          token token_class, m[7]
+          token Text::Whitespace, m[8]
+          push :tag_markup
+        end
+
+        # other tags or blocks
+        rule %r/([^\s%]+)(\s*)/ do
+          groups Name::Tag, Text::Whitespace
+          push :tag_markup
+        end
+      end
+
+      state :output do
+        rule %r/(\|)(\s*)([a-zA-Z_][^\s}\|:]*)/ do
+          groups Punctuation, Text::Whitespace, Name::Function
+          push :filters
+        end
+
+        mixin :end_of_tag
+        mixin :generic
+      end
+
+      state :filters do
+        rule %r/(\|)(\s*)([a-zA-Z_][^\s%}\|:]*)/ do
+          groups Punctuation, Text::Whitespace, Name::Function
+        end
+
+        mixin :end_of_tag
+        mixin :end_of_block
+        mixin :variable_param_markup
+      end
+
+      state :condition do
+        rule %r/([=!]=|[<>]=?)/, Operator
+        rule %r/(and|or|contains)\b/, Operator::Word
+
+        mixin :end_of_block
+        mixin :generic
+      end
+
+      state :when do
+        mixin :end_of_block
+        mixin :generic
+      end
+
+      state :end_of_tag do
+        rule(/-?\}\}/) { token Punctuation; reset_stack }
+      end
+
+      state :end_of_block do
+        rule(/-?%\}/) { token Punctuation; reset_stack }
+      end
+
+      # states for unknown markup
+      state :param_markup do
+        mixin :whitespace
+        mixin :keyword
+        mixin :string
+        mixin :number
+
+        rule %r/([^\s=:]+)(\s*)(=|:)/ do
+          groups Name::Attribute, Text::Whitespace, Operator
+        end
+
+        rule %r/[,:]/, Punctuation
+      end
+
+      state :default_param_markup do
+        mixin :param_markup
+
+        rule %r/\S+/, Text
+      end
+
+      state :variable_param_markup do
+        mixin :param_markup
+        mixin :variable
+
+        rule %r/\S+/, Text
+      end
+
+      state :tag_markup do
+        rule %r/(reversed)\b/, Name::Attribute
+
+        mixin :end_of_block
+        mixin :default_param_markup
+      end
+
+      state :variable_tag_markup do
+        mixin :end_of_block
+        mixin :variable_param_markup
+      end
+
+      # states for different values types
+      state :keyword do
+        rule %r/(false|true|nil)\b/, Keyword::Constant
+      end
+
+      state :variable do
+        rule %r/(empty|blank|forloop\.[^\s%}\|:]+)\b/, Name::Builtin
+        rule %r/\.(?=\w)|\[|\]/, Punctuation
+        rule %r/(first|last|size)\b/, Name::Function
+        rule %r/[a-zA-Z_][\w-]*\??/, Name::Variable
+      end
+
+      state :string do
+        rule %r/'[^']*'/, Str::Single
+        rule %r/"[^"]*"/, Str::Double
+      end
+
+      state :number do
+        rule %r/-/, Operator
+        rule %r/\d+\.\d+/, Num::Float
+        rule %r/\d+/, Num::Integer
+      end
+
+      state :generic do
+        mixin :whitespace
+        mixin :keyword
+        mixin :string
+        mixin :number
+        mixin :variable
+      end
+
+      state :whitespace do
+        rule %r/[ \t]+/, Text::Whitespace
+      end
+
+      state :comment do
+        rule %r/[^\{]+/, Comment
+
+        rule %r/(\{%-?)(\s*)(endcomment)(\s*)(-?%\})/ do
+          groups Punctuation, Text::Whitespace, Name::Tag, Text::Whitespace, Punctuation
+          reset_stack
+        end
+
+        rule %r/\{/, Comment
+      end
+
+      state :raw do
+        rule %r/[^\{]+/, Text
+
+        rule %r/(\{%-?)(\s*)(endraw)(\s*)(-?%\})/ do
+          groups Punctuation, Text::Whitespace, Name::Tag, Text::Whitespace, Punctuation
+          reset_stack
+        end
+
+        rule %r/\{/, Text
+      end
+
+      state :assign do
+        rule %r/=/, Operator
+
+        rule %r/(\|)(\s*)([a-zA-Z_][^\s%\|:]*)/ do
+          groups Punctuation, Text::Whitespace, Name::Function
+          push :filters
+        end
+
+        mixin :end_of_block
+        mixin :generic
+      end
+
+      state :include do
+        rule %r/(\{\{-?)(\s*)/ do
+          groups Punctuation, Text::Whitespace
+          push :output_embed
+        end
+
+        rule %r/(with|for)\b/, Name::Tag
+        rule %r/[\/\w-]+(\.[\w-]+)+\b/, Text
+
+        mixin :variable_tag_markup
+      end
+
+      state :output_embed do
+        rule %r/(\|)(\s*)([a-zA-Z_][^\s}\|:]*)/ do
+          groups Punctuation, Text::Whitespace, Name::Function
+        end
+
+        rule %r/-?\}\}/, Punctuation, :pop!
+
+        mixin :variable_param_markup
+      end
+    end
+  end
+end

data/lib/rouge/lexers/literate_coffeescript.rb

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class LiterateCoffeescript < RegexLexer
+      tag 'literate_coffeescript'
+      title "Literate CoffeeScript"
+      desc 'Literate coffeescript'
+      aliases 'litcoffee'
+      filenames '*.litcoffee'
+
+      def markdown
+        @markdown ||= Markdown.new(options)
+      end
+
+      def coffee
+        @coffee ||= Coffeescript.new(options)
+      end
+
+      start { markdown.reset!; coffee.reset! }
+
+      state :root do
+        rule %r/^(    .*?\n)+/m do
+          delegate coffee
+        end
+
+        rule %r/^([ ]{0,3}(\S.*?|)\n)*/m do
+          delegate markdown
+        end
+      end
+    end
+  end
+end

data/lib/rouge/lexers/literate_haskell.rb

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class LiterateHaskell < RegexLexer
+      title "Literate Haskell"
+      desc 'Literate haskell'
+      tag 'literate_haskell'
+      aliases 'lithaskell', 'lhaskell', 'lhs'
+      filenames '*.lhs'
+      mimetypes 'text/x-literate-haskell'
+
+      def haskell
+        @haskell ||= Haskell.new(options)
+      end
+
+      start { haskell.reset! }
+
+      # TODO: support TeX versions as well.
+      state :root do
+        rule %r/\s*?\n(?=>)/, Text, :code
+        rule %r/.*?\n/, Text
+        rule %r/.+\z/, Text
+      end
+
+      state :code do
+        rule %r/(>)( .*?(\n|\z))/ do |m|
+          token Name::Label, m[1]
+          delegate haskell, m[2]
+        end
+
+        rule %r/\s*\n(?=\s*[^>])/, Text, :pop!
+      end
+    end
+  end
+end

data/lib/rouge/lexers/llvm.rb

@@ -0,0 +1,97 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class LLVM < RegexLexer
+      title "LLVM"
+      desc 'The LLVM Compiler Infrastructure (http://llvm.org/)'
+      tag 'llvm'
+
+      filenames '*.ll'
+      mimetypes 'text/x-llvm'
+
+      string = /"[^"]*?"/
+      identifier = /([-a-zA-Z$._][-a-zA-Z$._0-9]*|#{string})/
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          addrspace addrspacecast alias align alignstack allocsize alwaysinline
+          appending arcp argmemonly arm_aapcs_vfpcc arm_aapcscc arm_apcscc asm
+          attributes available_externally begin builtin byval c cc ccc cold
+          coldcc common constant convergent datalayout dbg declare default
+          define dllexport dllimport end eq exact extern_weak external false
+          fast fastcc gc global hidden inaccessiblemem_or_argmemonly
+          inaccessiblememonly inbounds inlinehint inreg internal jumptable
+          landingpad linker_private linkonce linkonce_odr minsize module naked
+          ne nest ninf nnan no-jump-tables noalias nobuiltin nocapture
+          nocf_check noduplicate noimplicitfloat noinline nonlazybind norecurse
+          noredzone noredzone noreturn nounwind nsw nsz null nuw oeq oge ogt
+          ole olt one opaque optforfuzzing optnone optsize ord personality
+          private protected ptx_device ptx_kernel readnone readonly
+          returns_twice safestack sanitize_address sanitize_hwaddress
+          sanitize_memory sanitize_thread section sge sgt shadowcallstack
+          sideeffect signext sle slt speculatable speculative_load_hardening
+          sret ssp sspreq sspstrong strictfp tail target thread_local to triple
+          true type ueq uge ugt ule ult undef une unnamed_addr uno uwtable
+          volatile weak weak_odr writeonly x x86_fastcallcc x86_stdcallcc
+          zeroext zeroinitializer
+        )
+      end
+
+      def self.instructions
+        @instructions ||= Set.new %w(
+          add alloca and ashr bitcast br call catch cleanup extractelement
+          extractvalue fadd fcmp fdiv fmul fpext fptosi fptoui fptrunc free
+          frem fsub getelementptr getresult icmp insertelement insertvalue
+          inttoptr invoke load lshr malloc mul or phi ptrtoint resume ret sdiv
+          select sext shl shufflevector sitofp srem store sub switch trunc udiv
+          uitofp unreachable unwind urem va_arg xor zext
+        )
+      end
+
+      def self.types
+        @types ||= Set.new %w(
+          double float fp128 half label metadata ppc_fp128 void x86_fp80 x86mmx
+        )
+      end
+
+      state :basic do
+        rule %r/;.*?$/, Comment::Single
+        rule %r/\s+/, Text
+
+        rule %r/#{identifier}\s*:/, Name::Label
+
+        rule %r/@(#{identifier}|\d+)/, Name::Variable::Global
+        rule %r/#\d+/, Name::Variable::Global
+        rule %r/(%|!)#{identifier}/, Name::Variable
+        rule %r/(%|!)\d+/, Name::Variable
+
+        rule %r/c?#{string}/, Str
+
+        rule %r/0[xX][a-fA-F0-9]+/, Num
+        rule %r/-?\d+(?:[.]\d+)?(?:[eE][-+]?\d+(?:[.]\d+)?)?/, Num
+
+        rule %r/[=<>{}\[\]()*.,!]|x/, Punctuation
+      end
+
+      state :root do
+        mixin :basic
+
+        rule %r/i[1-9]\d*/, Keyword::Type
+
+        rule %r/\w+/ do |m|
+          if self.class.types.include? m[0]
+            token Keyword::Type
+          elsif self.class.instructions.include? m[0]
+            token Keyword
+          elsif self.class.keywords.include? m[0]
+            token Keyword
+          else
+            token Error
+          end
+        end
+      end
+    end
+  end
+end