rouge 1.10.1 → 1.11.0

data/lib/rouge/lexers/apiblueprint.rb

@@ -0,0 +1,51 @@
+module Rouge
+  module Lexers
+    load_lexer 'markdown.rb'
+
+    class APIBlueprint < Markdown
+      title 'API Blueprint'
+      desc 'Markdown based API description language.'
+
+      tag 'apiblueprint'
+      aliases 'apiblueprint', 'apib'
+      filenames '*.apib'
+      mimetypes 'text/vnd.apiblueprint'
+
+      def self.analyze_text(text)
+        return 1 if text.start_with?('FORMAT: 1A\n')
+      end
+
+      prepend :root do
+        # Metadata
+        rule(/(\S+)(:\s*)(.*)$/) do
+          groups Name::Variable, Punctuation, Literal::String
+        end
+
+        # Resource Group
+        rule(/^(#+)(\s*Group\s+)(.*)$/) do
+          groups Punctuation, Keyword, Generic::Heading
+        end
+
+        # Resource \ Action
+        rule(/^(#+)(.*)(\[.*\])$/) do
+          groups Punctuation, Generic::Heading, Literal::String
+        end
+
+        # Relation
+        rule(/^([\+\-\*])(\s*Relation:)(\s*.*)$/) do
+          groups Punctuation, Keyword, Literal::String
+        end
+
+        # MSON
+        rule(/^(\s+[\+\-\*]\s*)(Attributes|Parameters)(.*)$/) do
+          groups Punctuation, Keyword, Literal::String
+        end
+
+        # Request/Response
+        rule(/^([\+\-\*]\s*)(Request|Response)(\s+\d\d\d)?(.*)$/) do
+          groups Punctuation, Keyword, Literal::Number, Literal::String
+        end
+      end
+    end
+  end
+end

data/lib/rouge/lexers/biml.rb

@@ -0,0 +1,41 @@
+module Rouge
+  module Lexers
+    load_lexer 'xml.rb'
+        
+    class BIML < XML
+      title "BIML"
+      desc "BIML, Business Intelligence Markup Language"
+      tag 'biml'
+      filenames '*.biml'
+            
+      def self.analyze_text(text)
+        return 1 if text =~ /<\s*Biml\b/
+      end
+            
+      prepend :root do
+        rule %r(<#@\s*)m, Name::Tag, :directive_tag
+              
+        rule %r(<#[=]?\s*)m, Name::Tag, :directive_as_csharp
+      end
+            
+      prepend :attr do
+        #TODO: how to deal with embedded <# tags inside a attribute string
+        #rule %r("<#[=]?\s*)m, Name::Tag, :directive_as_csharp
+      end
+            
+      state :directive_as_csharp do
+        rule /\s*#>\s*/m, Name::Tag, :pop! 
+        rule %r(.*?(?=\s*#>\s*))m do
+          delegate CSharp
+        end
+      end
+            
+      state :directive_tag do
+        rule /\s+/m, Text
+        rule /[\w.:-]+\s*=/m, Name::Attribute, :attr
+        rule /[\w]+\s*/m, Name::Attribute
+        rule %r(/?\s*#>), Name::Tag, :pop!
+      end
+    end
+  end
+end

data/lib/rouge/lexers/c.rb

@@ -19,6 +19,9 @@ module Rouge
           auto break case const continue default do else enum extern
           for goto if register restricted return sizeof static struct
           switch typedef union volatile virtual while
+
+          _Alignas _Alignof _Atomic _Generic _Imaginary
+          _Noreturn _Static_assert _Thread_local
         )
       end
 
@@ -38,6 +41,8 @@ module Rouge
           int_fast64_t uint_fast8_t uint_fast16_t uint_fast32_t
           uint_fast64_t intptr_t uintptr_t intmax_t
           uintmax_t
+
+          char16_t char32_t
         )
       end
 
@@ -96,8 +101,8 @@ module Rouge
 
       state :statements do
         mixin :whitespace
-        rule /L?"/, Str, :string
-        rule %r(L?'(\\.|\\[0-7]{1,3}|\\x[a-f0-9]{1,2}|[^\\'\n])')i, Str::Char
+        rule /(u8|u|U|L)?"/, Str, :string
+        rule %r((u8|u|U|L)?'(\\.|\\[0-7]{1,3}|\\x[a-f0-9]{1,2}|[^\\'\n])')i, Str::Char
         rule %r((\d+[.]\d*|[.]?\d+)e[+-]?\d+[lu]*)i, Num::Float
         rule %r(\d+e[+-]?\d+[lu]*)i, Num::Float
         rule /0x[0-9a-f]+[lu]*/i, Num::Hex

data/lib/rouge/lexers/ceylon.rb

@@ -0,0 +1,123 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class Ceylon < RegexLexer
+      tag 'ceylon'
+      filenames '*.ceylon'
+      mimetypes 'text/x-ceylon'
+
+      title "Ceylon"
+      desc 'Say more, more clearly.'
+
+      keywords = %w(
+        break case catch continue else finally for in
+        if return switch this throw try while is exists dynamic
+        nonempty then outer assert let
+      )
+      
+      keywords_declaration = %w(
+        abstracts extends satisfies super given of out assign
+      )
+      
+      keywords_type = %w(
+        function value void new
+      )
+      
+      keywords_namespace = %w(
+        assembly module package
+      )
+      
+      keywords_constant = %w(
+        true false null
+      )
+
+      annotations = %w(
+        shared abstract formal default actual variable deprecated small
+        late literal doc by see throws optional license tagged final native
+        annotation sealed
+      )
+
+      state :whitespace do
+        rule %r([^\S\n]+), Text
+        rule %r(//.*?\n), Comment::Single
+        rule %r(/\*), Comment::Multiline
+      end
+
+      state :root do
+        mixin :whitespace
+
+        rule %r((shared|abstract|formal|default|actual|variable|deprecated|small|
+          late|literal|doc|by|see|throws|optional|license|tagged|final|native|
+          annotation|sealed)\b), Name::Decorator
+
+        rule %r((break|case|catch|continue|else|finally|for|in|
+          if|return|switch|this|throw|try|while|is|exists|dynamic|
+          nonempty|then|outer|assert|let)\b), Keyword
+
+        rule %r((abstracts|extends|satisfies|super|given|of|out|assign)\b), Keyword::Declaration
+
+        rule %r((function|value|void|new)\b), Keyword::Type
+        
+        rule %r((assembly|module|package)(\s+)) do
+          groups Keyword::Namespace, Text
+          push :import
+        end
+        
+        rule %r((true|false|null)\b), Keyword::Constant
+        
+        rule %r((class|interface|object|alias)(\s+)) do
+          groups Keyword::Declaration, Text
+          push :class
+        end
+
+        rule %r((import)(\s+)) do
+          groups Keyword::Namespace, Text
+          push :import
+        end
+        
+        rule %r("(\\\\|\\"|[^"])*"), Literal::String
+        rule %r('\\.'|'[^\\]'|'\\\{#[0-9a-fA-F]{4}\}'), Literal::String::Char
+        rule %r(".*``.*``.*"', String::Interpol
+        rule %r(\.)([a-z_]\w*)) do
+          groups Operator, Name::Attribute
+        end
+        rule %r([a-zA-Z_]\w*:), Name::Label
+        rule %r((\\I[a-z]|[A-Z])\w*), Name::Decorator
+        rule %r([a-zA-Z_]\w*), Name
+        rule %r([~^*!%&\[\](){}<>|+=:;,./?-`]), Operator
+        rule %r(\d{1,3}(_\d{3})+\.\d{1,3}(_\d{3})+[kMGTPmunpf]?), Literal::Number::Float
+        rule %r(\d{1,3}(_\d{3})+\.[0-9]+([eE][+-]?[0-9]+)?[kMGTPmunpf]?),
+          Literal::Number::Float
+        rule %r([0-9][0-9]*\.\d{1,3}(_\d{3})+[kMGTPmunpf]?), Literal::Number::Float
+        rule %r([0-9][0-9]*\.[0-9]+([eE][+-]?[0-9]+)?[kMGTPmunpf]?),
+          Literal::Number::Float
+        rule %r(#([0-9a-fA-F]{4})(_[0-9a-fA-F]{4})+), Literal::Number::Hex
+        rule %r(#[0-9a-fA-F]+), Literal::Number::Hex
+        rule %r(\$([01]{4})(_[01]{4})+), Literal::Number::Bin
+        rule %r(\$[01]+), Literal::Number::Bin
+        rule %r(\d{1,3}(_\d{3})+[kMGTP]?), Literal::Number::Integer
+        rule %r([0-9]+[kMGTP]?), Literal::Number::Integer
+        rule %r(\n), Text
+
+      end
+
+      state :class do
+        mixin :whitespace
+        rule %r([A-Za-z_]\w*), Name::Class, :pop!
+      end
+
+      state :import do
+        rule %r([a-z][\w.]*), Name::Namespace, :pop!
+        rule %r("(\\\\|\\"|[^"])*"), Literal::String, :pop!
+      end
+      
+      state :comment do
+        rule %r([^*/]), Comment.Multiline
+        rule %r(/\*), Comment::Multiline, :push!
+        rule %r(\*/), Comment::Multiline, :pop!
+        rule %r([*/]), Comment::Multiline
+      end
+    end
+  end
+end

data/lib/rouge/lexers/clojure.rb

@@ -9,7 +9,7 @@ module Rouge
       tag 'clojure'
       aliases 'clj', 'cljs'
 
-      filenames '*.clj', '*.cljs'
+      filenames '*.clj', '*.cljs', '*.cljc'
 
       mimetypes 'text/x-clojure', 'application/x-clojure'
 

data/lib/rouge/lexers/cmake.rb

@@ -0,0 +1,206 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class CMake < RegexLexer
+      title 'CMake'
+      desc 'The cross-platform, open-source build system'
+      tag 'cmake'
+      filenames 'CMakeLists.txt', '*.cmake'
+      mimetypes 'text/x-cmake'
+
+      SPACE = '[ \t]'
+      BRACKET_OPEN = '\[=*\['
+
+      STATES_MAP = {
+        :root => Text,
+        :bracket_string => Str::Double,
+        :quoted_argument => Str::Double,
+        :bracket_comment => Comment::Multiline,
+        :variable_reference => Name::Variable,
+      }
+
+      BUILTIN_COMMANDS = Set.new %w[
+        add_compile_options
+        add_custom_command
+        add_custom_target
+        add_definitions
+        add_dependencies
+        add_executable
+        add_library
+        add_subdirectory
+        add_test
+        aux_source_directory
+        break
+        build_command
+        build_name
+        cmake_host_system_information
+        cmake_minimum_required
+        cmake_policy
+        configure_file
+        create_test_sourcelist
+        define_property
+        else
+        elseif
+        enable_language
+        enable_testing
+        endforeach
+        endfunction
+        endif
+        endmacro
+        endwhile
+        exec_program
+        execute_process
+        export
+        export_library_dependencies
+        file
+        find_file
+        find_library
+        find_package
+        find_path
+        find_program
+        fltk_wrap_ui
+        foreach
+        function
+        get_cmake_property
+        get_directory_property
+        get_filename_component
+        get_property
+        get_source_file_property
+        get_target_property
+        get_test_property
+        if
+        include
+        include_directories
+        include_external_msproject
+        include_regular_expression
+        install
+        install_files
+        install_programs
+        install_targets
+        link_directories
+        link_libraries
+        list
+        load_cache
+        load_command
+        macro
+        make_directory
+        mark_as_advanced
+        math
+        message
+        option
+        output_required_files
+        project
+        qt_wrap_cpp
+        qt_wrap_ui
+        remove
+        remove_definitions
+        return
+        separate_arguments
+        set
+        set_directory_properties
+        set_property
+        set_source_files_properties
+        set_target_properties
+        set_tests_properties
+        site_name
+        source_group
+        string
+        subdir_depends
+        subdirs
+        target_compile_definitions
+        target_compile_options
+        target_include_directories
+        target_link_libraries
+        try_compile
+        try_run
+        unset
+        use_mangled_mesa
+        utility_source
+        variable_requires
+        variable_watch
+        while
+        write_file
+      ]
+
+      state :default do
+        rule /\r\n?|\n/ do
+          token STATES_MAP[state.name.to_sym]
+        end
+        rule /./ do
+          token STATES_MAP[state.name.to_sym]
+        end
+      end
+
+      state :variable_interpolation do
+        rule /\$\{/ do
+          token Str::Interpol
+          push :variable_reference
+        end
+      end
+
+      state :bracket_close do
+        rule /\]=*\]/ do |m|
+          token STATES_MAP[state.name.to_sym]
+          goto :root if m[0].length == @bracket_len
+        end
+      end
+
+      state :root do
+        mixin :variable_interpolation
+
+        rule /#{SPACE}/, Text
+        rule /[()]/, Punctuation
+
+        rule /##{BRACKET_OPEN}/ do |m|
+          token Comment::Multiline
+          @bracket_len = m[0].length - 1 # decount '#'
+          goto :bracket_comment
+        end
+        rule /#{BRACKET_OPEN}/ do |m|
+          token Str::Double
+          @bracket_len = m[0].length
+          goto :bracket_string
+        end
+
+        rule /"/, Str::Double, :quoted_argument
+
+        rule /([A-Za-z_][A-Za-z0-9_]*)(#{SPACE}*)(\()/ do |m|
+          groups BUILTIN_COMMANDS.include?(m[1]) ? Name::Builtin : Name::Function, Text, Punctuation
+        end
+
+        rule /#.*/, Comment::Single
+
+        mixin :default
+      end
+
+      state :bracket_string do
+        mixin :bracket_close
+        mixin :variable_interpolation
+        mixin :default
+      end
+
+      state :bracket_comment do
+        mixin :bracket_close
+        mixin :default
+      end
+
+      state :variable_reference do
+        mixin :variable_interpolation
+
+        rule /}/, Str::Interpol, :pop!
+
+        mixin :default
+      end
+
+      state :quoted_argument do
+        mixin :variable_interpolation
+
+        rule /"/, Str::Double, :root
+        rule /\\[()#" \\$@^trn;]/, Str::Escape
+
+        mixin :default
+      end
+    end
+  end
+end