rouge_ecl 0.0.1

data/lib/rouge/lexers/liquid.rb

@@ -0,0 +1,287 @@
+# -*- coding: utf-8 -*- #
+
+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 /[^\{]+/, Text
+
+        rule /(\{%)(\s*)/ do
+          groups Punctuation, Text::Whitespace
+          push :tag_or_block
+        end
+
+        rule /(\{\{)(\s*)/ do
+          groups Punctuation, Text::Whitespace
+          push :output
+        end
+
+        rule /\{/, Text
+      end
+
+      state :tag_or_block do
+        # builtin logic blocks
+        rule /(if|unless|elsif|case)(?=\s+)/, Keyword::Reserved, :condition
+
+        rule /(when)(\s+)/ do
+          groups Keyword::Reserved, Text::Whitespace
+          push :when
+        end
+
+        rule /(else)(\s*)(%\})/ do
+          groups Keyword::Reserved, Text::Whitespace, Punctuation
+          pop!
+        end
+
+        # other builtin blocks
+        rule /(capture)(\s+)([^\s%]+)(\s*)(%\})/ do
+          groups Name::Tag, Text::Whitespace, Name::Attribute, Text::Whitespace, Punctuation
+          pop!
+        end
+
+        rule /(comment)(\s*)(%\})/ do
+          groups Name::Tag, Text::Whitespace, Punctuation
+          push :comment
+        end
+
+        rule /(raw)(\s*)(%\})/ do
+          groups Name::Tag, Text::Whitespace, Punctuation
+          push :raw
+        end
+
+        rule /assign/, Name::Tag, :assign
+        rule /include/, Name::Tag, :include
+
+        # end of block
+        rule /(end(case|unless|if))(\s*)(%\})/ do
+          groups Keyword::Reserved, nil, Text::Whitespace, Punctuation
+          pop!
+        end
+
+        rule /(end([^\s%]+))(\s*)(%\})/ do
+          groups Name::Tag, nil, Text::Whitespace, Punctuation
+          pop!
+        end
+
+        # builtin tags
+        rule /(cycle)(\s+)(([^\s:]*)(:))?(\s*)/ do |m|
+          token Name::Tag, m[1]
+          token Text::Whitespace, m[2]
+
+          if m[4] =~ /'[^']*'/
+            token Str::Single, m[4]
+          elsif m[4] =~ /"[^"]*"/
+            token Str::Double, m[4]
+          else
+            token Name::Attribute, m[4]
+          end
+
+          token Punctuation, m[5]
+          token Text::Whitespace, m[6]
+
+          push :variable_tag_markup
+        end
+
+        # other tags or blocks
+        rule /([^\s%]+)(\s*)/ do
+          groups Name::Tag, Text::Whitespace
+          push :tag_markup
+        end
+      end
+
+      state :output do
+        mixin :whitespace
+        mixin :generic
+
+        rule /\}\}/, Punctuation, :pop!
+        rule /\|/, Punctuation, :filters
+      end
+
+      state :filters do
+        mixin :whitespace
+
+        rule(/\}\}/) { token Punctuation; reset_stack }
+
+        rule /([^\s\|:]+)(:?)(\s*)/ do
+          groups Name::Function, Punctuation, Text::Whitespace
+          push :filter_markup
+        end
+      end
+
+      state :filter_markup do
+        rule /\|/, Punctuation, :pop!
+
+        mixin :end_of_tag
+        mixin :end_of_block
+        mixin :default_param_markup
+      end
+
+      state :condition do
+        mixin :end_of_block
+        mixin :whitespace
+
+        rule /([=!><]=?)/, Operator
+
+        rule /\b((!)|(not\b))/ do
+          groups nil, Operator, Operator::Word
+        end
+
+        rule /(contains)/, Operator::Word
+
+        mixin :generic
+        mixin :whitespace
+      end
+
+      state :when do
+        mixin :end_of_block
+        mixin :whitespace
+        mixin :generic
+      end
+
+      state :operator do
+        rule /(\s*)((=|!|>|<)=?)(\s*)/ do
+          groups Text::Whitespace, Operator, nil, Text::Whitespace
+          pop!
+        end
+
+        rule /(\s*)(\bcontains\b)(\s*)/ do
+          groups Text::Whitespace, Operator::Word, Text::Whitespace
+          pop!
+        end
+      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 :string
+
+        rule /([^\s=:]+)(\s*)(=|:)/ do
+          groups Name::Attribute, Text::Whitespace, Operator
+        end
+
+        rule /(\{\{)(\s*)([^\s\}])(\s*)(\}\})/ do
+          groups Punctuation, Text::Whitespace, nil, Text::Whitespace, Punctuation
+        end
+
+        mixin :number
+        mixin :keyword
+
+        rule /,/, Punctuation
+      end
+
+      state :default_param_markup do
+        mixin :param_markup
+        rule /./, Text
+      end
+
+      state :variable_param_markup do
+        mixin :param_markup
+        mixin :variable
+        rule /./, Text
+      end
+
+      state :tag_markup do
+        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 /\b(false|true)\b/, Keyword::Constant
+      end
+
+      state :variable do
+        rule /\.(?=\w)/, Punctuation
+        rule /[a-zA-Z_]\w*\??/, Name::Variable
+      end
+
+      state :string do
+        rule /'[^']*'/, Str::Single
+        rule /"[^"]*"/, Str::Double
+      end
+
+      state :number do
+        rule /\d+\.\d+/, Num::Float
+        rule /\d+/, Num::Integer
+      end
+
+      state :array_index do
+        rule /\[/, Punctuation
+        rule /\]/, Punctuation
+      end
+
+      state :generic do
+        mixin :array_index
+        mixin :keyword
+        mixin :string
+        mixin :variable
+        mixin :number
+      end
+
+      state :whitespace do
+        rule /[ \t]+/, Text::Whitespace
+      end
+
+      state :comment do
+        rule /(\{%)(\s*)(endcomment)(\s*)(%\})/ do
+          groups Punctuation, Text::Whitespace, Name::Tag, Text::Whitespace, Punctuation
+          reset_stack
+        end
+
+        rule /./, Comment
+      end
+
+      state :raw do
+        rule /[^\{]+/, Text
+
+        rule /(\{%)(\s*)(endraw)(\s*)(%\})/ do
+          groups Punctuation, Text::Whitespace, Name::Tag, Text::Whitespace, Punctuation
+          reset_stack
+        end
+
+        rule /\{/, Text
+      end
+
+      state :assign do
+        mixin :whitespace
+        mixin :end_of_block
+
+        rule /(\s*)(=)(\s*)/ do
+          groups Text::Whitespace, Operator, Text::Whitespace
+        end
+
+        rule /\|/, Punctuation, :filters
+
+        mixin :generic
+      end
+
+      state :include do
+        mixin :whitespace
+
+        rule /([^\.]+)(\.)(html|liquid)/ do
+          groups Name::Attribute, Punctuation, Name::Attribute
+        end
+
+        mixin :variable_tag_markup
+      end
+    end
+  end
+end

data/lib/rouge/lexers/literate_coffeescript.rb

@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*- #
+
+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 /^(    .*?\n)+/m do
+          delegate coffee
+        end
+
+        rule /^([ ]{0,3}(\S.*?|)\n)*/m do
+          delegate markdown
+        end
+      end
+    end
+  end
+end

data/lib/rouge/lexers/literate_haskell.rb

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*- #
+
+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 /\s*?\n(?=>)/, Text, :code
+        rule /.*?\n/, Text
+        rule /.+\z/, Text
+      end
+
+      state :code do
+        rule /(>)( .*?(\n|\z))/ do |m|
+          token Name::Label, m[1]
+          delegate haskell, m[2]
+        end
+
+        rule /\s*\n(?=\s*[^>])/, Text, :pop!
+      end
+    end
+  end
+end

data/lib/rouge/lexers/llvm.rb

@@ -0,0 +1,80 @@
+# -*- coding: utf-8 -*- #
+
+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})/
+
+      state :basic do
+        rule /;.*?$/, Comment::Single
+        rule /\s+/, Text
+
+        rule /#{identifier}\s*:/, Name::Label
+
+        rule /@(#{identifier}|\d+)/, Name::Variable::Global
+        rule /(%|!)#{identifier}/, Name::Variable
+        rule /(%|!)\d+/, Name::Variable
+
+        rule /c?#{string}/, Str
+
+        rule /0[xX][a-fA-F0-9]+/, Num
+        rule /-?\d+(?:[.]\d+)?(?:[eE][-+]?\d+(?:[.]\d+)?)?/, Num
+
+        rule /[=<>{}\[\]()*.,!]|x/, Punctuation
+      end
+
+      builtin_types = %w(
+        void float double half x86_fp80 x86mmx fp128 ppc_fp128 label metadata
+      )
+
+      state :types do
+        rule /i[1-9]\d*/, Keyword::Type
+        rule /#{builtin_types.join('|')}/, Keyword::Type
+      end
+
+      builtin_keywords = %w(
+        begin end true false declare define global constant personality private
+        landingpad linker_private internal available_externally linkonce_odr
+        linkonce weak weak_odr appending dllimport dllexport common default
+        hidden protected extern_weak external thread_local zeroinitializer
+        undef null to tail target triple datalayout volatile nuw nsw nnan ninf
+        nsz arcp fast exact inbounds align addrspace section alias module asm
+        sideeffect gc dbg ccc fastcc coldcc x86_stdcallcc x86_fastcallcc
+        arm_apcscc arm_aapcscc arm_aapcs_vfpcc ptx_device ptx_kernel cc
+        c signext zeroext inreg sret nounwind noreturn noalias nocapture byval
+        nest readnone readonly inlinehint noinline alwaysinline optsize ssp
+        sspreq noredzone noimplicitfloat naked type opaque eq ne slt sgt sle
+        sge ult ugt ule uge oeq one olt ogt ole oge ord uno unnamed_addr ueq
+        une uwtable x
+      )
+
+      builtin_instructions = %w(
+        add fadd sub fsub mul fmul udiv sdiv fdiv urem srem frem shl lshr ashr
+        and or xor icmp fcmp phi call catch trunc zext sext fptrunc fpext
+        uitofp sitofp fptoui fptosi inttoptr ptrtoint bitcast select va_arg ret
+        br switch invoke unwind unreachable malloc alloca free load store
+        getelementptr extractelement insertelement shufflevector getresult
+        extractvalue insertvalue cleanup resume
+      )
+
+      state :keywords do
+        rule /#{builtin_instructions.join('|')}/, Keyword
+        rule /#{builtin_keywords.join('|')}/, Keyword
+      end
+
+      state :root do
+        mixin :basic
+        mixin :keywords
+        mixin :types
+      end
+    end
+  end
+end

data/lib/rouge/lexers/lua.rb

@@ -0,0 +1,125 @@
+# -*- coding: utf-8 -*- #
+
+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