rouge 3.24.0 → 3.27.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ff5fdf4ccf2083c09f6ce1c899d36f7ef50b2f4bb70e5fa04dc18ce239422f8a
-  data.tar.gz: e40152f9290403580be90d096219bf81a92750e8c02be04f05d6929b1fb186ba
+  metadata.gz: 396c335066b8bb01574b5d81b25d43a98b58dd1bad1d3d9588b7a35c573e2209
+  data.tar.gz: d899fb3968d38a1a93415c21c62e332f1a8ba230952c0a33adda5c4755c4c8f3
 SHA512:
-  metadata.gz: e9c0bcf9114cb6b260d611777dbeaa7649bc20ad298ddc73fa2b606ca871615051c7f46abfbed3d8121ec08b505e1c3c4c86c2140d5c30a6c6104dae12d15b11
-  data.tar.gz: 061b7d77b9162d45ff5416fefa9a2052199745b31e3897170c79e46311a6b36de959b1f030a903130dda3941c0ca217c13012f27a5c840f0c07b0912b02a93c7
+  metadata.gz: c1fed00ea4906f18e1939675dff9c02508cddef4b1878622422d66b3cbee6d07111ab434cb83314d5d3077f3b86375424d4af05f2fce46cb105a9ecef698aec9
+  data.tar.gz: 7764c52128ef376d3af7e2c5d1a958a62bddffadc4b2d8c868161fd786a9af63827d143a8b85d6d5251d65f8adefc6a405e2fef5d29e6c7d73bc00f041d8c024

data/Gemfile

@@ -8,6 +8,7 @@ gem 'rake'
 
 gem 'minitest', '>= 5.0'
 gem 'minitest-power_assert'
+gem 'power_assert', '~> 1.2'
 
 gem 'parallel', '~> 1.13.0' if RUBY_VERSION < '2.2.0'
 gem 'rubocop', '~> 0.49.1'

data/lib/rouge/demos/dafny

@@ -0,0 +1,16 @@
+module A {
+  const i: int := 56_78
+}
+
+method m(b: bool, s: string) {
+  var x: string;
+  var i: int;
+  if b then i := 1; else i := 2;
+  i := if b 1 else 2;
+  assert b;
+  assume b;
+  print s;
+  expect b;
+}
+
+function f(i: int): int { i + 1 }

data/lib/rouge/demos/ocl

@@ -0,0 +1,4 @@
+context Compagnie::toEuros() : Collection(Real)
+body: self.employees->collect(each: Employee| each.salary/ 6.55957)
+-- OR
+body: self.employees->collect(salary) -> collect(x | x/6.55957)

data/lib/rouge/demos/rescript

@@ -0,0 +1,26 @@
+module Person = {
+  type t = Teacher | Director | Student(string)
+
+  let greeting = person =>
+    switch person {
+    | Teacher => "Hey Professor!"
+    | Director => "Hello Director."
+    | Student("Richard") => "Still here Ricky?"
+    | Student(other) => "Hey, " ++ other ++ "."
+    }
+}
+
+module Button = {
+  @react.component
+  let make = (~count: int, ~onClick) => {
+    let times = switch count {
+    | 1 => "once"
+    | 2 => "twice"
+    | n => Belt.Int.toString(n) ++ " times"
+    }
+
+    let msg = "Click me " ++ times
+
+    <button onClick> {msg->React.string} </button>
+  }
+}

data/lib/rouge/formatter.rb

@@ -42,8 +42,8 @@ module Rouge
     end
 
     # Format a token stream.  Delegates to {#format}.
-    def self.format(tokens, *a, &b)
-      new(*a).format(tokens, &b)
+    def self.format(tokens, *args, **kwargs, &b)
+      new(*args, **kwargs).format(tokens, &b)
     end
 
     def initialize(opts={})

data/lib/rouge/formatters/html_line_highlighter.rb

@@ -13,10 +13,8 @@ module Rouge
       end
 
       def stream(tokens)
-        lineno = 0
-        token_lines(tokens) do |tokens_in_line|
-          lineno += 1
-          line = %(#{@delegate.format(tokens_in_line)}\n)
+        token_lines(tokens).with_index(1) do |line_tokens, lineno|
+          line = %(#{@delegate.format(line_tokens)}\n)
           line = %(<span class="#{@highlight_line_class}">#{line}</span>) if @highlight_lines.include? lineno
           yield line
         end

data/lib/rouge/formatters/html_line_table.rb

@@ -32,10 +32,8 @@ module Rouge
       end
 
       def stream(tokens, &b)
-        lineno = @start_line - 1
         buffer = [%(<table class="#@table_class"><tbody>)]
-        token_lines(tokens) do |line_tokens|
-          lineno += 1
+        token_lines(tokens).with_index(@start_line) do |line_tokens, lineno|
           buffer << %(<tr id="#{sprintf @line_id, lineno}" class="#@line_class">)
           buffer << %(<td class="#@gutter_class gl" )
           buffer << %(style="-moz-user-select: none;-ms-user-select: none;)

data/lib/rouge/formatters/html_linewise.rb

@@ -11,9 +11,8 @@ module Rouge
       end
 
       def stream(tokens, &b)
-        lineno = 0
-        token_lines(tokens) do |line_tokens|
-          yield %(<#{@tag_name} class="#{sprintf @class_format, lineno += 1}">)
+        token_lines(tokens).with_index(1) do |line_tokens, lineno|
+          yield %(<#{@tag_name} class="#{sprintf @class_format, lineno}">)
           @formatter.stream(line_tokens) {|formatted| yield formatted }
           yield %(\n</#{@tag_name}>)
         end

data/lib/rouge/lexers/batchfile.rb

@@ -79,6 +79,7 @@ module Rouge
       state :basic do
         # Comments
         rule %r/@?\brem\b.*$/i, Comment
+
         # Empty Labels
         rule %r/^::.*$/, Comment
 
@@ -105,7 +106,7 @@ module Rouge
           end
         end
 
-        rule %r/([\/\-+][a-z]+)\s*/i, Name::Attribute
+        rule %r/((?:[\/\+]|--?)[a-z]+)\s*/i, Name::Attribute
 
         mixin :expansions
 

data/lib/rouge/lexers/ceylon.rb

@@ -51,8 +51,8 @@ module Rouge
 
         rule %r("(\\\\|\\"|[^"])*"), Literal::String
         rule %r('\\.'|'[^\\]'|'\\\{#[0-9a-fA-F]{4}\}'), Literal::String::Char
-        rule %r(".*``.*``.*"', String::Interpol
-        rule %r(\.)([a-z_]\w*)) do
+        rule %r("[^`]*``[^`]*``[^`]*"), Literal::String::Interpol
+        rule %r((\.)([a-z_]\w*)) do
           groups Operator, Name::Attribute
         end
         rule %r([a-zA-Z_]\w*:), Name::Label

data/lib/rouge/lexers/cmake.rb

@@ -22,6 +22,7 @@ module Rouge
       }
 
       BUILTIN_COMMANDS = Set.new %w[
+        add_compile_definitions
         add_compile_options
         add_custom_command
         add_custom_target
@@ -29,6 +30,7 @@ module Rouge
         add_dependencies
         add_executable
         add_library
+        add_link_options
         add_subdirectory
         add_test
         aux_source_directory
@@ -36,7 +38,9 @@ module Rouge
         build_command
         build_name
         cmake_host_system_information
+        cmake_language
         cmake_minimum_required
+        cmake_parse_arguments
         cmake_policy
         configure_file
         create_test_sourcelist
@@ -74,6 +78,7 @@ module Rouge
         include
         include_directories
         include_external_msproject
+        include_guard
         include_regular_expression
         install
         install_files
@@ -110,9 +115,14 @@ module Rouge
         subdir_depends
         subdirs
         target_compile_definitions
+        target_compile_features
         target_compile_options
         target_include_directories
+        target_link_directories
         target_link_libraries
+        target_link_options
+        target_precompile_headers
+        target_sources
         try_compile
         try_run
         unset

data/lib/rouge/lexers/cpp.rb

@@ -59,11 +59,11 @@ module Rouge
       prepend :statements do
         rule %r/(class|struct)\b/, Keyword, :classname
         rule %r/template\b/, Keyword, :template
-        rule %r/\d+(\.\d+)?(?:h|(?:min)|s|(?:ms)|(?:us)|(?:ns))/, Num::Other
+        rule %r/#{dq}(\.#{dq})?(?:y|d|h|(?:min)|s|(?:ms)|(?:us)|(?:ns)|i|(?:if)|(?:il))\b/, Num::Other
         rule %r((#{dq}[.]#{dq}?|[.]#{dq})(e[+-]?#{dq}[lu]*)?)i, Num::Float
         rule %r(#{dq}e[+-]?#{dq}[lu]*)i, Num::Float
         rule %r/0x\h('?\h)*[lu]*/i, Num::Hex
-        rule %r/0b[01]+(?:_[01]+)*/, Num::Bin
+        rule %r/0b[01]+('[01]+)*/, Num::Bin
         rule %r/0[0-7]('?[0-7])*[lu]*/i, Num::Oct
         rule %r/#{dq}[lu]*/i, Num::Integer
         rule %r/\bnullptr\b/, Name::Builtin

data/lib/rouge/lexers/crystal.rb

@@ -25,8 +25,7 @@ module Rouge
         )xi, Str::Symbol
 
         # special symbols
-        rule %r(:(?:\*\*|[-+]@|[/\%&\|^`~]|\[\]=?|<<|>>|<=?>|<=?|===?)),
-          Str::Symbol
+        rule %r(:(?:===|=?~|\[\][=?]?|\*\*=?|\/\/=?|[=^*/+-]=?|&[&*+-]?=?|\|\|?=?|![=~]?|%=?|<=>|<<?=?|>>?=?|\.\.\.?)), Str::Symbol
 
         rule %r/:'(\\\\|\\'|[^'])*'/, Str::Symbol
         rule %r/:"/, Str::Symbol, :simple_sym
@@ -36,7 +35,7 @@ module Rouge
         # %-sigiled strings
         # %(abc), %[abc], %<abc>, %.abc., %r.abc., etc
         delimiter_map = { '{' => '}', '[' => ']', '(' => ')', '<' => '>' }
-        rule %r/%([rqswQWxiI])?([^\w\s])/ do |m|
+        rule %r/%([rqswQWxiI])?([^\w\s}])/ do |m|
           open = Regexp.escape(m[2])
           close = Regexp.escape(delimiter_map[m[2]] || m[2])
           interp = /[rQWxI]/ === m[1]
@@ -79,9 +78,11 @@ module Rouge
       state :strings do
         mixin :symbols
         rule %r/\b[a-z_]\w*?[?!]?:\s+/, Str::Symbol, :expr_start
-        rule %r/'(\\\\|\\'|[^'])*'/, Str::Single
         rule %r/"/, Str::Double, :simple_string
         rule %r/(?<!\.)`/, Str::Backtick, :simple_backtick
+        rule %r/(')(\\u[a-fA-F0-9]{4}|\\u\{[a-fA-F0-9]{1,6}\}|\\[abefnrtv])?(\\\\|\\'|[^'])*(')/ do
+          groups Str::Single, Str::Escape, Str::Single, Str::Single
+        end
       end
 
       state :regex_flags do
@@ -154,11 +155,13 @@ module Rouge
         mixin :whitespace
         rule %r/__END__/, Comment::Preproc, :end_part
 
-        rule %r/0_?[0-7]+(?:_[0-7]+)*/, Num::Oct
+        rule %r/0o[0-7]+(?:_[0-7]+)*/, Num::Oct
         rule %r/0x[0-9A-Fa-f]+(?:_[0-9A-Fa-f]+)*/, Num::Hex
         rule %r/0b[01]+(?:_[01]+)*/, Num::Bin
-        rule %r/\d+\.\d+(e[\+\-]?\d+)?/, Num::Float
-        rule %r/[\d]+(?:_\d+)*/, Num::Integer
+        rule %r/\d+\.\d+(e[\+\-]?\d+)?(_f32)?/i, Num::Float
+        rule %r/\d+(e[\+\-]?\d+)/i, Num::Float
+        rule %r/\d+_f32/i, Num::Float
+        rule %r/[\d]+(?:_\d+)*(_[iu]\d+)?/, Num::Integer
 
         rule %r/@\[([^\]]+)\]/, Name::Decorator
 
@@ -183,7 +186,7 @@ module Rouge
           groups Keyword, Text, Name::Namespace
         end
 
-        rule %r/(def\b)(\s*)/ do
+        rule %r/(def|macro\b)(\s*)/ do
           groups Keyword, Text
           push :funcname
         end
@@ -212,8 +215,9 @@ module Rouge
 
         rule %r/[a-zA-Z_]\w*[?!]/, Name, :expr_start
         rule %r/[a-zA-Z_]\w*/, Name, :method_call
-        rule %r/\*\*|<<?|>>?|>=|<=|<=>|=~|={3}|!~|&&?|\|\||\./,
+        rule %r/\*\*|\/\/|>=|<=|<=>|<<?|>>?|=~|={3}|!~|&&?|\|\||\./,
           Operator, :expr_start
+        rule %r/{%|%}/, Punctuation
         rule %r/[-+\/*%=<>&!^|~]=?/, Operator, :expr_start
         rule(/[?]/) { token Punctuation; push :ternary; push :expr_start }
         rule %r<[\[({,:\\;/]>, Punctuation, :expr_start
@@ -346,6 +350,7 @@ module Rouge
         mixin :string_intp
         rule %r/\\([\\abefnrstv#"']|x[a-fA-F0-9]{1,2}|[0-7]{1,3})/,
           Str::Escape
+        rule %r/\\u([a-fA-F0-9]{4}|\{[^}]+\})/, Str::Escape
         rule %r/\\./, Str::Escape
       end
 

data/lib/rouge/lexers/dafny.rb

@@ -0,0 +1,128 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Dafny < RegexLexer
+      title "Dafny"
+      desc "The Dafny programming language (github.com/dafny-lang/dafny)"
+      tag "dafny"
+      filenames "*.dfy"
+      mimetypes "text/x-dafny"
+
+      keywords = %w(
+        abstract allocated assert assume
+        break by
+        calc case class codatatype const constructor
+        datatype decreases downto
+        else ensures exists expect export extends
+        false for forall fresh function
+        ghost greatest
+        if import include invariant iterator
+        label least lemma
+        match method modifies modify module
+        nameonly new newtype null
+        old opened
+        predicate print provides
+        reads refines requires return returns reveal reveals
+        static
+        then this to trait true twostate type
+        unchanged
+        var
+        while witness
+        yield yields
+      )
+
+      literals = %w{ true false null }
+
+      textOperators = %w{ as is in }
+
+      types = %w(bool char int real string nat
+                 array array? object object? ORDINAL
+                 seq set iset map imap multiset )
+
+      idstart = /[0-9a-zA-Z?]/
+      idchar = /[0-9a-zA-Z_'?]/
+      id = /#{idstart}#{idchar}*/
+
+      arrayType = /array(?:1[0-9]+|[2-9][0-9]*)\??(?!#{idchar})/
+      bvType = /bv(?:0|[1-9][0-9]*)(?!#{idchar})/
+
+      digit = /\d/
+      digits = /#{digit}+(?:_#{digit}+)*/
+      bin_digits = /[01]+(?:_[01]+)*/
+      hex_digit = /(?:[0-9a-fA-F])/
+      hex_digits = /#{hex_digit}+(?:_#{hex_digit}+)*/
+
+      cchar = /(?:[^\\'\n\r]|\\["'ntr\\0])/
+      schar = /(?:[^\\"\n\r]|\\["'ntr\\0])/
+      uchar = /(?:\\u#{hex_digit}{4})/
+
+      ## IMPORTANT: Rules are ordered, which allows later rules to be 
+      ## simpler than they would otherwise be
+      state :root do
+        rule %r(/\*), Comment::Multiline, :comment
+        rule %r(//.*?$), Comment::Single
+        rule %r(\*/), Error          # should not have closing comment in :root
+                                     # is an improperly nested comment
+
+        rule %r/'#{cchar}'/, Str::Char           # standard or escape char
+        rule %r/'#{uchar}'/, Str::Char           # unicode char
+        rule %r/'[^'\n\r]*'/, Error              # bad any other enclosed char
+        rule %r/'[^'\n\r]*$/, Error              # bad unclosed char
+
+        rule %r/"(?:#{schar}|#{uchar})*"/, Str::Double        # valid string
+        rule %r/".*"/, Error                     # anything else that is closed
+        rule %r/".*$/, Error                     # bad unclosed string
+
+        rule %r/@"([^"]|"")*"/, Str::Other     # valid verbatim string
+        rule %r/@".*/m, Error             # anything else , multiline unclosed
+
+
+        rule %r/#{digits}\.#{digits}(?!#{idchar})/, Num::Float
+        rule %r/0b#{bin_digits}(?!#{idchar})/, Num::Bin
+        rule %r/0b#{idchar}*/, Error
+        rule %r/0x#{hex_digits}(?!#{idchar})/, Num::Hex
+        rule %r/0x#{idchar}*/, Error
+        rule %r/#{digits}(?!#{idchar})/, Num::Integer
+        rule %r/_(?!#{idchar})/, Name
+        rule %r/_[0-9_]+[_]?(?!#{idchar})/, Error
+        rule %r/[0-9_]+_(?!#{idchar})/, Error
+        rule %r/[0-9]#{idchar}+/, Error
+
+        rule %r/#{arrayType}/, Keyword::Type
+        rule %r/#{bvType}/, Keyword::Type
+
+        rule id do |m|
+          if types.include?(m[0])
+            token Keyword::Type
+          elsif literals.include?(m[0])
+            token Keyword::Constant
+          elsif textOperators.include?(m[0])
+            token Operator::Word
+          elsif keywords.include?(m[0])
+            token Keyword::Reserved
+          else
+            token Name
+          end
+        end
+
+        rule %r/\.\./, Operator
+        rule %r/[*!%&<>\|^+=:.\/-]/, Operator
+        rule %r/[\[\](){},;`]/, Punctuation
+
+        rule %r/[^\S\n]+/, Text
+        rule %r/\n/, Text
+        rule %r/./, Error # Catchall
+      end
+
+      state :comment do
+        rule %r(\*/), Comment::Multiline, :pop!
+        rule %r(/\*), Comment::Multiline, :comment
+        rule %r([^*/]+), Comment::Multiline
+        rule %r(.), Comment::Multiline
+      end
+
+    end
+  end
+end

data/lib/rouge/lexers/docker.rb

@@ -7,7 +7,7 @@ module Rouge
       title "Docker"
       desc "Dockerfile syntax"
       tag 'docker'
-      aliases 'dockerfile'
+      aliases 'dockerfile', 'Dockerfile'
       filenames 'Dockerfile', '*.Dockerfile', '*.docker'
       mimetypes 'text/x-dockerfile-config'
 

data/lib/rouge/lexers/eex.rb

@@ -7,9 +7,9 @@ module Rouge
       desc "Embedded Elixir"
 
       tag 'eex'
-      aliases 'leex'
+      aliases 'leex', 'heex'
 
-      filenames '*.eex', '*.leex'
+      filenames '*.eex', '*.leex', '*.heex'
 
       def initialize(opts={})
         @elixir_lexer = Elixir.new(opts)

data/lib/rouge/lexers/factor.rb

@@ -243,8 +243,8 @@ module Rouge
         end
 
         # strings
-        rule %r/"""\s+.*?\s+"""/, Str
-        rule %r/"(\\.|[^\\])*?"/, Str
+        rule %r/"(?:\\\\|\\"|[^"])*"/, Str
+        rule %r/\S+"\s+(?:\\\\|\\"|[^"])*"/, Str
         rule %r/(CHAR:)(\s+)(\\[\\abfnrstv]*|\S)(?=\s)/, Str::Char
 
         # comments

data/lib/rouge/lexers/ghc_core.rb

@@ -17,7 +17,7 @@ module Rouge
         rule %r/^=====.*=====$/, Generic::Heading
         # timestamps
         rule %r/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d+ UTC$/, Comment::Single
-        rule %r/^Result size of .+\s*.*}/, Comment::Multiline
+        rule %r/^Result size of .+\n.+{[^}]*}/, Comment::Multiline
         rule %r/--.*$/, Comment::Single
 
         rule %r/\[/, Comment::Special, :annotation

data/lib/rouge/lexers/javascript.rb

@@ -272,7 +272,8 @@ module Rouge
         rule %r/[$]{/, Punctuation, :template_string_expr
         rule %r/`/, Str::Double, :pop!
         rule %r/\\[$`]/, Str::Escape
-        rule %r/[$]/, Str::Double
+        rule %r/[^$`\\]+/, Str::Double
+        rule %r/[\\$]/, Str::Double
       end
 
       state :template_string_expr do

data/lib/rouge/lexers/jsl.rb

@@ -14,42 +14,53 @@ module Rouge
         rule %r/\s+/m, Text::Whitespace
 
         rule %r(//.*?$), Comment::Single
-        rule %r(/\*.*?\*/)m, Comment::Multiline
+        rule %r'/[*].*?', Comment::Multiline, :comment # multiline block comment
 
         # messages
-        rule %r/(<<)(.*?)(\(|;)/ do |m|
-          groups Operator, Name::Function, Punctuation
-        end
+        rule %r/<</, Operator, :message
 
         # covers built-in and custom functions
-        rule %r/([a-z_][\w\s'%.\\]*)(\()/i do |m|
-          groups Keyword, Punctuation
+        rule %r/(::|:)?([a-z_][\w\s'%.\\]*)(\()/i do |m|
+          groups Punctuation, Keyword, Punctuation
         end
 
-        rule %r/\b[+-]?(?:[0-9]+(?:\.[0-9]+)?|\.[0-9]+|\.)(?:e[+-]?[0-9]+)?i?\b/i, Num
-
         rule %r/\d{2}(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\d{2}(\d{2})?(:\d{2}:\d{2}(:\d{2}(\.\d*)?)?)?/i, Literal::Date
 
-        rule %r/::[a-z_][\w\s'%.\\]*/i, Name::Variable
-        rule %r/:\w+/, Name
-        rule %r/[a-z_][\w\s'%.\\]*/i, Name::Variable
-        rule %r/"(?:\\!"|[^"])*?"n/m, Name::Variable
+        rule %r/-?(?:[0-9]+(?:[.][0-9]+)?|[.][0-9]*)(?:e[+-]?[0-9]+)?i?/i, Num
+
+        rule %r/(::|:)?([a-z_][\w\s'%.\\]*|"(?:\\!"|[^"])*?"n)/i do |m|
+          groups Punctuation, Name::Variable
+        end
 
         rule %r/(")(\\\[)(.*?)(\]\\)(")/m do
           groups Str::Double, Str::Escape, Str::Double, Str::Escape, Str::Double  # escaped string
         end
         rule %r/"/, Str::Double, :dq
 
-        rule %r/[-+*\/!%&<>\|=:]/, Operator
+        rule %r/[-+*\/!%&<>\|=:`^]/, Operator
         rule %r/[\[\](){},;]/, Punctuation
       end
 
+      state :message do
+        rule %r/\s+/m, Text::Whitespace
+        rule %r/[a-z_][\w\s'%.\\]*/i, Name::Function
+        rule %r/[(),;]/, Punctuation, :pop!
+        rule %r/[&|!=<>]/, Operator, :pop!
+      end
+
       state :dq do
         rule %r/\\![btrnNf0\\"]/, Str::Escape
         rule %r/\\/, Str::Double
         rule %r/"/, Str::Double, :pop!
         rule %r/[^\\"]+/m, Str::Double
       end
+
+      state :comment do
+        rule %r'/[*]', Comment::Multiline, :comment
+        rule %r'[*]/', Comment::Multiline, :pop!
+        rule %r'[^/*]+', Comment::Multiline
+        rule %r'[/*]', Comment::Multiline
+      end
     end
   end
 end

data/lib/rouge/lexers/kotlin.rb

@@ -53,7 +53,7 @@ module Rouge
           groups Keyword::Declaration, Text
           push :property
         end
-        rule %r'(return|continue|break|this|super)(@#{name})?' do
+        rule %r'(return|continue|break|this|super)(@#{name})?\b' do
           groups Keyword, Name::Decorator
         end
         rule %r'\bfun\b', Keyword

data/lib/rouge/lexers/ocaml/common.rb

@@ -3,7 +3,7 @@
 
 module Rouge
   module Lexers
-    # shared states with Reasonml
+    # shared states with Reasonml and ReScript
     class OCamlCommon < RegexLexer
       def self.keywords
         @keywords ||= Set.new %w(

data/lib/rouge/lexers/ocl.rb

@@ -0,0 +1,85 @@
+module Rouge
+  module Lexers
+    class OCL < RegexLexer
+      title "OCL"
+      desc "OMG Object Constraint Language (omg.org/spec/OCL)"
+      tag 'ocl'
+      aliases 'OCL'
+      filenames '*.ocl'
+      mimetypes 'text/x-ocl'
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          context pre post inv init body def derive if then else endif import
+          package endpackage let in
+        )
+      end
+
+      def self.keywords_type
+        @keywords_type ||= Set.new %w(
+          Boolean Integer UnlimitedNatural Real String OrderedSet Tuple Bag Set
+          Sequence OclInvalid OclVoid TupleType OclState Collection OclMessage
+        )
+      end
+
+      def self.builtins
+        @builtins ||= Set.new %w(
+          self null result true false invalid @pre
+          )
+      end
+
+      def self.operators
+        @operators ||= Set.new %w(
+          or xor and not implies
+        )
+      end
+
+      def self.functions
+        @functions ||= Set.new %w(
+          oclAsSet oclIsNew oclIsUndefined oclIsInvalid oclAsType oclIsTypeOf
+          oclIsKindOf oclInState oclType oclLocale hasReturned result
+          isSignalSent isOperationCallabs floor round max min toString div mod
+          size substring concat toInteger toReal toUpperCase toLowerCase
+          indexOf equalsIgnoreCase at characters toBoolean includes excludes
+          count includesAll excludesAll isEmpty notEmpty sum product
+          selectByKind selectByType asBag asSequence asOrderedSet asSet flatten
+          union intersection including excluding symmetricDifferencecount
+          append prepend insertAt subOrderedSet first last reverse subSequence
+          any closure collect collectNested exists forAll isUnique iterate one
+          reject select sortedBy allInstances average conformsTo
+        )
+      end
+
+      state :single_string do
+        rule %r/\\./, Str::Escape
+        rule %r/'/, Str::Single, :pop!
+        rule %r/[^\\']+/, Str::Single
+      end
+
+      state :root do
+        rule %r/\s+/m, Text
+        rule %r/--.*/, Comment::Single
+        rule %r/\d+/, Num::Integer
+        rule %r/'/, Str::Single, :single_string
+        rule %r([->|+*/<>=~!@#%&|?^-]), Operator
+        rule %r/[;:()\[\],.]/, Punctuation
+        rule %r/\w[\w\d]*/ do |m|
+          if self.class.operators.include? m[0]
+            token Operator
+          elsif self.class.keywords_type.include? m[0]
+            token Keyword::Declaration
+          elsif self.class.keywords.include? m[0]
+            token Keyword
+          elsif self.class.builtins.include? m[0]
+            token Name::Builtin
+          elsif self.class.functions.include? m[0]
+            token Name::Function
+          else
+            token Name
+          end
+        end
+      end
+    end
+  end
+end
+