rouge-alda 3.3.0

data/lib/rouge/lexers/lua.rb

@@ -0,0 +1,126 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Lua < RegexLexer
+      title "Lua"
+      desc "Lua (http://www.lua.org)"
+      tag 'lua'
+      filenames '*.lua', '*.wlua'
+
+      mimetypes 'text/x-lua', 'application/x-lua'
+
+      option :function_highlighting, 'Whether to highlight builtin functions (default: true)'
+      option :disabled_modules, 'builtin modules to disable'
+
+      def initialize(opts={})
+        @function_highlighting = opts.delete(:function_highlighting) { true }
+        @disabled_modules = opts.delete(:disabled_modules) { [] }
+        super(opts)
+      end
+
+      def self.detect?(text)
+        return true if text.shebang? 'lua'
+      end
+
+      def self.builtins
+        load Pathname.new(__FILE__).dirname.join('lua/builtins.rb')
+        self.builtins
+      end
+
+      def builtins
+        return [] unless @function_highlighting
+
+        @builtins ||= Set.new.tap do |builtins|
+          self.class.builtins.each do |mod, fns|
+            next if @disabled_modules.include? mod
+            builtins.merge(fns)
+          end
+        end
+      end
+
+      state :root do
+        # lua allows a file to start with a shebang
+        rule %r(#!(.*?)$), Comment::Preproc
+        rule //, Text, :base
+      end
+
+      state :base do
+        rule %r(--\[(=*)\[.*?\]\1\])m, Comment::Multiline
+        rule %r(--.*$), Comment::Single
+
+        rule %r((?i)(\d*\.\d+|\d+\.\d*)(e[+-]?\d+)?'), Num::Float
+        rule %r((?i)\d+e[+-]?\d+), Num::Float
+        rule %r((?i)0x[0-9a-f]*), Num::Hex
+        rule %r(\d+), Num::Integer
+
+        rule %r(\n), Text
+        rule %r([^\S\n]), Text
+        # multiline strings
+        rule %r(\[(=*)\[.*?\]\1\])m, Str
+
+        rule %r((==|~=|<=|>=|\.\.\.|\.\.|[=+\-*/%^<>#])), Operator
+        rule %r([\[\]\{\}\(\)\.,:;]), Punctuation
+        rule %r((and|or|not)\b), Operator::Word
+
+        rule %r((break|do|else|elseif|end|for|if|in|repeat|return|then|until|while)\b), Keyword
+        rule %r((local)\b), Keyword::Declaration
+        rule %r((true|false|nil)\b), Keyword::Constant
+
+        rule %r((function)\b), Keyword, :function_name
+
+        rule %r([A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)?) do |m|
+          name = m[0]
+          if self.builtins.include?(name)
+            token Name::Builtin
+          elsif name =~ /\./
+            a, b = name.split('.', 2)
+            token Name, a
+            token Punctuation, '.'
+            token Name, b
+          else
+            token Name
+          end
+        end
+
+        rule %r('), Str::Single, :escape_sqs
+        rule %r("), Str::Double, :escape_dqs
+      end
+
+      state :function_name do
+        rule /\s+/, Text
+        rule %r((?:([A-Za-z_][A-Za-z0-9_]*)(\.))?([A-Za-z_][A-Za-z0-9_]*)) do
+          groups Name::Class, Punctuation, Name::Function
+          pop!
+        end
+        # inline function
+        rule %r(\(), Punctuation, :pop!
+      end
+
+      state :escape_sqs do
+        mixin :string_escape
+        mixin :sqs
+      end
+
+      state :escape_dqs do
+        mixin :string_escape
+        mixin :dqs
+      end
+
+      state :string_escape do
+        rule %r(\\([abfnrtv\\"']|\d{1,3})), Str::Escape
+      end
+
+      state :sqs do
+        rule %r('), Str::Single, :pop!
+        rule %r([^']+), Str::Single
+      end
+
+      state :dqs do
+        rule %r("), Str::Double, :pop!
+        rule %r([^"]+), Str::Double
+      end
+    end
+  end
+end

data/lib/rouge/lexers/m68k.rb

@@ -0,0 +1,144 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class M68k < RegexLexer
+      tag 'm68k'
+
+      title "M68k"
+      desc "Motorola 68k Assembler"
+
+      ws = %r((?:\s|;.*?\n/)+)
+      id = /[a-zA-Z_][a-zA-Z0-9_]*/
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          abcd add adda addi addq addx and andi asl asr
+
+          bcc bcs beq bge bgt bhi ble bls blt bmi bne bpl bvc bvs bhs blo
+          bchg bclr bfchg bfclr bfests bfextu bfffo bfins bfset bftst bkpt bra bse bsr btst
+
+          callm cas cas2 chk chk2 clr cmp cmpa cmpi cmpm cmp2
+
+          dbcc dbcs dbeq dbge dbgt dbhi dble dbls dblt dbmi dbne dbpl dbvc dbvs dbhs dblo
+          dbra dbf dbt divs divsl divu divul
+
+          eor eori exg ext extb
+
+          illegal jmp jsr lea link lsl lsr
+
+          move movea move16 movem movep moveq muls mulu
+
+          nbcd neg negx nop not or ori
+
+          pack pea rol ror roxl roxr rtd rtm rtr rts
+
+          sbcd
+
+          seq sne spl smi svc svs st sf sge sgt sle slt scc shi sls scs shs slo
+          sub suba subi subq subx swap
+
+          tas trap trapcc TODO trapv tst
+
+          unlk unpk eori
+        )
+      end
+
+      def self.keywords_type
+        @keywords_type ||= Set.new %w(
+          dc ds dcb
+        )
+      end
+
+      def self.reserved
+        @reserved ||= Set.new %w(
+          include incdir incbin end endf endfunc endmain endproc fpu func machine main mmu opword proc set opt section
+          rept endr
+          ifeq ifne ifgt ifge iflt ifle iif ifd ifnd ifc ifnc elseif else endc
+          even cnop fail machine
+          output radix __G2 __LK
+          list nolist plen llen ttl subttl spc page listchar format
+          equ equenv equr set reg
+          rsreset rsset offset
+          cargs
+          fequ.s fequ.d fequ.x fequ.p fequ.w fequ.l fopt
+          macro endm mexit narg
+        )
+      end
+
+      def self.builtins
+        @builtins ||=Set.new %w(
+          d0 d1 d2 d3 d4 d5 d6 d7
+          a0 a1 a2 a3 a4 a5 a6 a7 a7'
+          pc usp ssp ccr
+        )
+      end
+
+      start { push :expr_bol }
+
+      state :expr_bol do
+        mixin :inline_whitespace
+        rule(//) { pop! }
+      end
+
+      state :inline_whitespace do
+        rule /[\s\t\r]+/, Text
+      end
+
+      state :whitespace do
+        rule /\n+/m, Text, :expr_bol
+        rule %r(^\*(\\.|.)*?\n), Comment::Single, :expr_bol
+        rule %r(;(\\.|.)*?\n), Comment::Single, :expr_bol
+        mixin :inline_whitespace
+      end
+
+      state :root do
+        rule(//) { push :statements }
+      end
+
+      state :statements do
+        mixin :whitespace
+        rule /"/, Str, :string
+        rule /#/, Name::Decorator
+        rule /^\.?[a-zA-Z0-9_]+:?/, Name::Label
+        rule /\.[bswl]\s/i, Name::Decorator
+        rule %r('(\\.|\\[0-7]{1,3}|\\x[a-f0-9]{1,2}|[^\\'\n])')i, Str::Char
+        rule /\$[0-9a-f]+/i, Num::Hex
+        rule /@[0-8]+/i, Num::Oct
+        rule /%[01]+/i, Num::Bin
+        rule /\d+/i, Num::Integer
+        rule %r([*~&+=\|?:<>/-]), Operator
+        rule /\\./, Comment::Preproc
+        rule /[(),.]/, Punctuation
+        rule /\[[a-zA-Z0-9]*\]/, Punctuation
+
+        rule id do |m|
+          name = m[0]
+
+          if self.class.keywords.include? name.downcase
+            token Keyword
+          elsif self.class.keywords_type.include? name.downcase
+            token Keyword::Type
+          elsif self.class.reserved.include? name.downcase
+            token Keyword::Reserved
+          elsif self.class.builtins.include? name.downcase
+            token Name::Builtin
+          elsif name =~ /[a-zA-Z0-9]+/
+            token Name::Variable
+          else
+            token Name
+          end
+        end
+      end
+
+      state :string do
+        rule /"/, Str, :pop!
+        rule /\\([\\abfnrtv"']|x[a-fA-F0-9]{2,4}|[0-7]{1,3})/, Str::Escape
+        rule /[^\\"\n]+/, Str
+        rule /\\\n/, Str
+        rule /\\/, Str # stray backslash
+      end
+    end
+  end
+end

data/lib/rouge/lexers/make.rb

@@ -0,0 +1,113 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Make < RegexLexer
+      title "Make"
+      desc "Makefile syntax"
+      tag 'make'
+      aliases 'makefile', 'mf', 'gnumake', 'bsdmake'
+      filenames '*.make', 'Makefile', 'makefile', 'Makefile.*', 'GNUmakefile'
+      mimetypes 'text/x-makefile'
+
+      bsd_special = %w(
+        include undef error warning if else elif endif for endfor
+      )
+
+      gnu_special = %w(
+        ifeq ifneq ifdef ifndef else endif include -include define endef :
+      )
+
+      line = /(?:\\.|\\\n|[^\\\n])*/m
+
+      def initialize(opts={})
+        super
+        @shell = Shell.new(opts)
+      end
+
+      start { @shell.reset! }
+
+      state :root do
+        rule /\s+/, Text
+
+        rule /#.*?\n/, Comment
+
+        rule /(export)(\s+)(?=[a-zA-Z0-9_\${}\t -]+\n)/ do
+          groups Keyword, Text
+          push :export
+        end
+
+        rule /export\s+/, Keyword
+
+        # assignment
+        rule /([a-zA-Z0-9_${}.-]+)(\s*)([!?:+]?=)/m do |m|
+          token Name::Variable, m[1]
+          token Text, m[2]
+          token Operator, m[3]
+          push :shell_line
+        end
+
+        rule /"(\\\\|\\.|[^"\\])*"/, Str::Double
+        rule /'(\\\\|\\.|[^'\\])*'/, Str::Single
+        rule /([^\n:]+)(:+)([ \t]*)/ do
+          groups Name::Label, Operator, Text
+          push :block_header
+        end
+      end
+
+      state :export do
+        rule /[\w\${}-]/, Name::Variable
+        rule /\n/, Text, :pop!
+        rule /\s+/, Text
+      end
+
+      state :block_header do
+        rule /[^,\\\n#]+/, Name::Function
+        rule /,/, Punctuation
+        rule /#.*?/, Comment
+        rule /\\\n/, Text
+        rule /\\./, Text
+        rule /\n/ do
+          token Text
+          goto :block_body
+        end
+      end
+
+      state :block_body do
+        rule /(\t[\t ]*)([@-]?)/ do |m|
+          groups Text, Punctuation
+          push :shell_line
+        end
+
+        rule(//) { @shell.reset!; pop! }
+      end
+
+      state :shell do
+        # macro interpolation
+        rule /\$\(\s*[a-z_]\w*\s*\)/i, Name::Variable
+        # $(shell ...)
+        rule /(\$\()(\s*)(shell)(\s+)/m do
+          groups Name::Function, Text, Name::Builtin, Text
+          push :shell_expr
+        end
+
+        rule(/\\./m) { delegate @shell }
+        stop = /\$\(|\(|\)|\\|$/
+        rule(/.+?(?=#{stop})/m) { delegate @shell }
+        rule(stop) { delegate @shell }
+      end
+
+      state :shell_expr do
+        rule(/\(/) { delegate @shell; push }
+        rule /\)/, Name::Variable, :pop!
+        mixin :shell
+      end
+
+      state :shell_line do
+        rule /\n/, Text, :pop!
+        mixin :shell
+      end
+    end
+  end
+end

data/lib/rouge/lexers/markdown.rb

@@ -0,0 +1,155 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Markdown < RegexLexer
+      title "Markdown"
+      desc "Markdown, a light-weight markup language for authors"
+
+      tag 'markdown'
+      aliases 'md', 'mkd'
+      filenames '*.markdown', '*.md', '*.mkd'
+      mimetypes 'text/x-markdown'
+
+      def html
+        @html ||= HTML.new(options)
+      end
+
+      start { html.reset! }
+
+      edot = /\\.|[^\\\n]/
+
+      state :root do
+        # YAML frontmatter
+        rule(/\A(---\s*\n.*?\n?)^(---\s*$\n?)/m) { delegate YAML }
+
+        rule /\\./, Str::Escape
+
+        rule /^[\S ]+\n(?:---*)\n/, Generic::Heading
+        rule /^[\S ]+\n(?:===*)\n/, Generic::Subheading
+
+        rule /^#(?=[^#]).*?$/, Generic::Heading
+        rule /^##*.*?$/, Generic::Subheading
+
+        rule /(\n[ \t]*)(```|~~~)(.*?)(\n.*?\n)(\2)/m do |m|
+          sublexer = Lexer.find_fancy(m[3].strip, m[4], @options)
+          sublexer ||= PlainText.new(@options.merge(:token => Str::Backtick))
+          sublexer.reset!
+
+          token Text, m[1]
+          token Punctuation, m[2]
+          token Name::Label, m[3]
+          delegate sublexer, m[4]
+          token Punctuation, m[5]
+        end
+
+        rule /\n\n((    |\t).*?\n|\n)+/, Str::Backtick
+
+        rule /(`+)(?:#{edot}|\n)+?\1/, Str::Backtick
+
+        # various uses of * are in order of precedence
+
+        # line breaks
+        rule /^(\s*[*]){3,}\s*$/, Punctuation
+        rule /^(\s*[-]){3,}\s*$/, Punctuation
+
+        # bulleted lists
+        rule /^\s*[*+-](?=\s)/, Punctuation
+
+        # numbered lists
+        rule /^\s*\d+\./, Punctuation
+
+        # blockquotes
+        rule /^\s*>.*?$/, Generic::Traceback
+
+        # link references
+        # [foo]: bar "baz"
+        rule %r(^
+          (\s*) # leading whitespace
+          (\[) (#{edot}+?) (\]) # the reference
+          (\s*) (:) # colon
+        )x do
+          groups Text, Punctuation, Str::Symbol, Punctuation, Text, Punctuation
+
+          push :title
+          push :url
+        end
+
+        # links and images
+        rule /(!?\[)(#{edot}*?)(\])/ do
+          groups Punctuation, Name::Variable, Punctuation
+          push :link
+        end
+
+        rule /[*][*]#{edot}*?[*][*]/, Generic::Strong
+        rule /__#{edot}*?__/, Generic::Strong
+
+        rule /[*]#{edot}*?[*]/, Generic::Emph
+        rule /_#{edot}*?_/, Generic::Emph
+
+        # Automatic links
+        rule /<.*?@.+[.].+>/, Name::Variable
+        rule %r[<(https?|mailto|ftp)://#{edot}*?>], Name::Variable
+
+
+        rule /[^\\`\[*\n&<]+/, Text
+
+        # inline html
+        rule(/&\S*;/) { delegate html }
+        rule(/<#{edot}*?>/) { delegate html }
+        rule /[&<]/, Text
+
+        rule /\n/, Text
+      end
+
+      state :link do
+        rule /(\[)(#{edot}*?)(\])/ do
+          groups Punctuation, Str::Symbol, Punctuation
+          pop!
+        end
+
+        rule /[(]/ do
+          token Punctuation
+          push :inline_title
+          push :inline_url
+        end
+
+        rule /[ \t]+/, Text
+
+        rule(//) { pop! }
+      end
+
+      state :url do
+        rule /[ \t]+/, Text
+
+        # the url
+        rule /(<)(#{edot}*?)(>)/ do
+          groups Name::Tag, Str::Other, Name::Tag
+          pop!
+        end
+
+        rule /\S+/, Str::Other, :pop!
+      end
+
+      state :title do
+        rule /"#{edot}*?"/, Name::Namespace
+        rule /'#{edot}*?'/, Name::Namespace
+        rule /[(]#{edot}*?[)]/, Name::Namespace
+        rule /\s*(?=["'()])/, Text
+        rule(//) { pop! }
+      end
+
+      state :inline_title do
+        rule /[)]/, Punctuation, :pop!
+        mixin :title
+      end
+
+      state :inline_url do
+        rule /[^<\s)]+/, Str::Other, :pop!
+        rule /\s+/m, Text
+        mixin :url
+      end
+    end
+  end
+end