rouge 3.30.0 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: acc37e14414bcaa3f67dda77f1b746f8035cfc972dc807610b4a1ef4fcffe848
-  data.tar.gz: 2380291e01345a7251f229dddf858d612f64d89f7ef93d7b75b2c44fa9a093a6
+  metadata.gz: 9229545bdc0804f0a7f0fea6a4fd1b94dbe8d022d0d29c1ffa254c09f42003d1
+  data.tar.gz: cf12e8de0f2d03d37ed6f1380a5deb04ad385d8628b4f2ed7c1921b16161636f
 SHA512:
-  metadata.gz: a4d60e1f37e66b4991b040ff82db8cc59983f37923a7f8b41a44a149407167467b443cd6ac8bb47f8800588e82301be1d58c14175bb1513a728952be21144ed8
-  data.tar.gz: 6f0e6ab3786ac315f0a2d658d02091bb3b8a0b6cd75ef3aac6dc2a116eee9dd5a45b1a4c9ef11f40f0f6338ae50d7c0f0b219e9ab20de950e4ae865f3824e002
+  metadata.gz: 31f64a3f386d01829f9a2d2e9711ad40c3c48fbf122dc66b0e9519d4c02676cf530879c388e280efd996d6a57ec3497f5faa54423d081af02450348037c58712
+  data.tar.gz: fad76c2d5d770fb172e09a2614e37ff78d362b81dfb73d50ce5c25de04f07c93aabae357e4a1a5b6b47be3792edf146e1299c1ec78204d55e998dd54c169f307

data/Gemfile

@@ -10,17 +10,14 @@ 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', '~> 1.0', '<= 1.11'
 gem 'rubocop-performance'
 
 # don't try to install redcarpet under jruby
-gem 'redcarpet', :platforms => :ruby
+gem 'redcarpet', platforms: :ruby
 
 # Profiling
-if RUBY_VERSION >= '2.3.0'
-  gem 'memory_profiler', :require => false
-end
+gem 'memory_profiler', require: false
 
 # Needed for a Rake task
 gem 'git'
@@ -33,11 +30,7 @@ group :development do
   gem 'github-markup'
 
   # for visual tests
-  if RUBY_VERSION < '2.2.0'
-    gem 'sinatra', '~> 1.4.8'
-  else
-    gem 'sinatra'
-  end
+  gem 'sinatra'
 
   # Ruby 3 no longer ships with a web server
   gem 'puma' if RUBY_VERSION >= '3'

data/lib/rouge/demos/rml

@@ -0,0 +1,33 @@
+// A system agnostic domain specific language for runtime monitoring and verification
+// Basic events
+
+insert(index,elem) matches {event:'func_pre',name:'my_insert',args:[index,elem]};
+
+relevant matches insert(_,_)|remove(_,_)|size(_)|get(_,_);
+
+insert_in_bounds(size) matches insert(index,_) with index >= 0 && index <= size;
+
+del_false matches del(_,false);
+not_add_true_del(el) not matches add(el,true) | del(el,_);
+
+Main = relevant >> (CheckIndex<0> /\ add_rm_get >> CheckElem)!;
+CheckIndex<size> =
+    get_size(size)* (insert_in_bounds(size) CheckIndex<size+1> \/ remove_in_bounds(size) CheckIndex<size-1>);
+
+Msg<inf,sup> = if(inf<=sup) msg(inf) Msg<inf+1,sup> else empty;
+Main=relevant>>Msg<1,4>*!;
+
+acquire(id) matches {event:'func_pre',name:'acquire',args:[_,id,...]};
+
+Main = relevant >> Resources;
+Resources =
+    {let id; acquire(id)
+        ((Resources | use(id)* release(id)) /\
+        acqRel(id) >> release(id) all)
+    }?;
+
+msg(ty) matches {event:'func_pre',name:'msg',args:[ty]};
+relevant matches msg(_);
+
+Msg<inf,sup> = if(inf<=sup) msg(inf) Msg<inf+1,sup> else empty;
+Main=relevant>>Msg<1,4>*!;

data/lib/rouge/lexers/diff.rb

@@ -20,9 +20,19 @@ module Rouge
       state :root do
         rule(/^ .*$\n?/, Text)
         rule(/^---$\n?/, Punctuation)
-        rule(/^[+>]+.*$\n?/, Generic::Inserted)
-        rule(/^\+.*$\n?/, Generic::Inserted)
-        rule(/^[-<]+.*$\n?/, Generic::Deleted)
+
+        rule %r(
+          (^\++.*$\n?) |
+          (^>+[ \t]+.*$\n?) |
+          (^>+$\n?)
+        )x, Generic::Inserted
+
+        rule %r(
+          (^-+.*$\n?) |
+          (^<+[ \t]+.*$\n?) |
+          (^<+$\n?)
+        )x, Generic::Deleted
+
         rule(/^!.*$\n?/, Generic::Strong)
         rule(/^([Ii]ndex|diff).*$\n?/, Generic::Heading)
         rule(/^(@@[^@]*@@)([^\n]*\n)/) do
@@ -30,7 +40,7 @@ module Rouge
         end
         rule(/^\w.*$\n?/, Punctuation)
         rule(/^=.*$\n?/, Generic::Heading)
-        rule(/\s.*$\n?/, Text)
+        rule(/.+$\n?/, Text)
       end
     end
   end

data/lib/rouge/lexers/haxe.rb

@@ -17,15 +17,15 @@ module Rouge
 
       def self.keywords
         @keywords ||= Set.new %w(
-          break case cast catch class continue default do else enum false for
-          function if import interface macro new null override package private
+          as break case cast catch class continue default do else enum false for
+          function if import in interface macro new null override package private
           public return switch this throw true try untyped while
         )
       end
 
       def self.imports
         @imports ||= Set.new %w(
-          import using
+          package import using
         )
       end
 
@@ -55,6 +55,7 @@ module Rouge
       end
 
       id = /[$a-zA-Z_][a-zA-Z0-9_]*/
+      dotted_id = /[$a-zA-Z_][a-zA-Z0-9_.]*/
 
       state :comments_and_whitespace do
         rule %r/\s+/, Text
@@ -77,6 +78,22 @@ module Rouge
         rule %r//, Text, :pop!
       end
 
+      state :namespace do
+        mixin :comments_and_whitespace
+
+        rule %r/
+           (#{dotted_id})
+           (\s+)(in|as)(\s+)
+           (#{id})
+         /x do
+          groups(Name::Namespace, Text::Whitespace, Keyword, Text::Whitespace, Name)
+        end
+
+        rule %r/#{dotted_id}/, Name::Namespace
+
+        rule(//) { pop! }
+      end
+
       state :regex do
         rule %r(/) do
           token Str::Regex
@@ -141,20 +158,22 @@ module Rouge
         end
 
         rule id do |m|
-          if self.class.keywords.include? m[0]
+          match = m[0]
+
+          if self.class.imports.include?(match)
+            token Keyword::Namespace
+            push :namespace
+          elsif self.class.keywords.include?(match)
             token Keyword
             push :expr_start
-          elsif self.class.imports.include? m[0]
-            token Keyword
-            push :namespace
-          elsif self.class.declarations.include? m[0]
+          elsif self.class.declarations.include?(match)
             token Keyword::Declaration
             push :expr_start
-          elsif self.class.reserved.include? m[0]
+          elsif self.class.reserved.include?(match)
             token Keyword::Reserved
-          elsif self.class.constants.include? m[0]
+          elsif self.class.constants.include?(match)
             token Keyword::Constant
-          elsif self.class.builtins.include? m[0]
+          elsif self.class.builtins.include?(match)
             token Name::Builtin
           else
             token Name::Other

data/lib/rouge/lexers/http.rb

@@ -46,7 +46,7 @@ module Rouge
 
         # response
         rule %r(
-          (HTTPS?)(/)(\d(?:\.\d))([ ]+)  # http version
+          (HTTPS?)(/)(\d(?:\.\d)?)([ ]+) # http version
           (\d{3})([ ]+)?                 # status
           ([^\r\n]*)?(\r?\n|$)           # status message
         )x do

data/lib/rouge/lexers/make.rb

@@ -20,11 +20,6 @@ module Rouge
         )
       end
 
-      # TODO: Add support for special keywords
-      # bsd_special = %w(
-      #   include undef error warning if else elif endif for endfor
-      # )
-
       def initialize(opts={})
         super
         @shell = Shell.new(opts)
@@ -41,11 +36,11 @@ module Rouge
           groups Keyword, Literal::String::Other
         end
 
-        rule %r/(ifn?def|ifn?eq)([\t ]+)([^#\n]+)/ do
+        rule %r/((?:ifn?def|ifn?eq|unexport)\b)([\t ]+)([^#\n]+)/ do
           groups Keyword, Text, Name::Variable
         end
 
-        rule %r/(?:else|endif)[\t ]*(?=[#\n])/, Keyword
+        rule %r/(?:else|endif|endef|endfor)[\t ]*(?=[#\n])/, Keyword
 
         rule %r/(export)([\t ]+)(?=[\w\${}()\t -]+\n)/ do
           groups Keyword, Text
@@ -55,10 +50,8 @@ module Rouge
         rule %r/export[\t ]+/, Keyword
 
         # assignment
-        rule %r/([\w${}().-]+)([\t ]*)([!?:+]?=)/m do |m|
-          token Name::Variable, m[1]
-          token Text, m[2]
-          token Operator, m[3]
+        rule %r/(override\b)*([\t ]*)([\w${}().-]+)([\t ]*)([!?:+]?=)/m do |m|
+          groups Name::Builtin, Text, Name::Variable, Text, Operator
           push :shell_line
         end
 
@@ -68,10 +61,19 @@ module Rouge
           groups Name::Label, Operator, Text
           push :block_header
         end
+
+        rule %r/(override\b)*([\t ])*(define)([\t ]+)([^#\n]+)/ do
+          groups Name::Builtin, Text, Keyword, Text, Name::Variable
+        end
+
+        rule %r/(\$[({])([\t ]*)(#{Make.functions.join('|')})([\t ]+)/m do
+          groups Name::Function, Text, Name::Builtin, Text
+          push :shell_expr
+        end
       end
 
       state :export do
-        rule %r/[\w\${}()-]/, Name::Variable
+        rule %r/[\w[\$]{1,2}{}()-]/, Name::Variable
         rule %r/\n/, Text, :pop!
         rule %r/[\t ]+/, Text
       end
@@ -107,22 +109,29 @@ module Rouge
 
       state :shell do
         # macro interpolation
-        rule %r/\$[({][\t ]*\w[\w:=%.]*[\t ]*[)}]/i, Name::Variable
+        rule %r/[\$]{1,2}[({]/, Punctuation, :macro_expr
+
         # function invocation
         rule %r/(\$[({])([\t ]*)(#{Make.functions.join('|')})([\t ]+)/m do
-          groups Name::Function, Text, Name::Builtin, Text
+          groups Punctuation, Text, Name::Builtin, Text
           push :shell_expr
         end
 
         rule(/\\./m) { delegate @shell }
-        stop = /\$\(|\$\{|\(|\)|\}|\\|$/
+        stop = /[\$]{1,2}\(|[\$]{1,2}\{|\(|\)|\}|\\|$/
         rule(/.+?(?=#{stop})/m) { delegate @shell }
         rule(stop) { delegate @shell }
       end
 
+      state :macro_expr do
+        rule %r/[)}]/, Punctuation, :pop!
+        rule %r/\n/, Text, :pop!
+        mixin :shell
+      end
+
       state :shell_expr do
         rule(/[({]/) { delegate @shell; push }
-        rule %r/[)}]/, Name::Function, :pop!
+        rule %r/[)}]/, Punctuation, :pop!
         mixin :shell
       end
 

data/lib/rouge/lexers/praat.rb

@@ -58,6 +58,16 @@ module Rouge
         linear randomGauss randomInteger randomUniform zero
       )
 
+      functions_matrix = %w(
+        linear mul mul_fast mul_metal mul_nt mul_tn mul_tt outer peaks
+        randomGamma randomGauss randomInteger randomUniform softmaxPerRow
+        solve transpose zero
+      )
+
+      functions_string_vector = %w(
+        empty fileNames folderNames readLinesFromFile splitByWhitespace
+      )
+
       objects = %w(
         Activation AffineTransform AmplitudeTier Art Artword Autosegment
         BarkFilter BarkSpectrogram CCA Categories Cepstrogram Cepstrum
@@ -142,6 +152,7 @@ module Rouge
 
         mixin :variable_name
         mixin :number
+        mixin :vector_literal
 
         rule %r/"/, Literal::String, :string
 
@@ -196,6 +207,8 @@ module Rouge
       state :function_call do
         rule %r/\b(#{functions_string.join('|')})\$(?=\s*[:(])/, Name::Function, :function
         rule %r/\b(#{functions_array.join('|')})#(?=\s*[:(])/,   Name::Function, :function
+        rule %r/\b(#{functions_matrix.join('|')})##(?=\s*[:(])/,   Name::Function, :function
+        rule %r/\b(#{functions_string_vector.join('|')})\$#(?=\s*[:(])/,   Name::Function, :function
         rule %r/\b(#{functions_numeric.join('|')})(?=\s*[:(])/,  Name::Function, :function
       end
 
@@ -214,7 +227,7 @@ module Rouge
           groups Text, Punctuation
         end
 
-        rule %r/\s*[\])\n]/, Text, :pop!
+        rule %r/\s*[\]\})\n]/, Text, :pop!
 
         rule %r/\s+/, Text
         rule %r/"/,   Literal::String, :string
@@ -224,6 +237,7 @@ module Rouge
         mixin :variable_name
         mixin :operator
         mixin :number
+        mixin :vector_literal
 
         rule %r/[()]/, Text
         rule %r/,/, Punctuation
@@ -257,11 +271,15 @@ module Rouge
           push :object_reference
         end
 
-        rule %r/\.?[a-z][a-zA-Z0-9_.]*(\$|#)?/, Text
+        rule %r/\.?[a-z][a-zA-Z0-9_.]*(\$#|##|\$|#)?/, Text
         rule %r/[\[\]]/, Text, :comma_list
         mixin :string_interpolated
       end
 
+      state :vector_literal do
+        rule %r/(\{)/, Text, :comma_list
+      end
+
       state :object_reference do
         mixin :string_interpolated
         rule %r/([a-z][a-zA-Z0-9_]*|\d+)/, Name::Builtin

data/lib/rouge/lexers/rml.rb

@@ -0,0 +1,142 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class RML < RegexLexer
+      title "RML"
+      desc "A system agnostic domain-specific language for runtime monitoring and verification (https://rmlatdibris.github.io/)"
+      tag 'rml'
+      filenames '*.rml'
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          matches not with empty
+          all if else true false
+        )
+      end
+
+      def self.arithmetic_keywords
+        @arithmetic_keywords ||= Set.new %w(
+          abs sin cos tan min max
+        )
+      end
+
+      id_char = /[a-zA-Z0-9_]/
+      uppercase_id = /[A-Z]#{id_char}*/
+      lowercase_id = /[a-z]#{id_char}*/
+
+      ellipsis = /(\.){3}/
+      int = /[0-9]+/
+      float = /#{int}\.#{int}/
+      string = /'(\\'|[ a-zA-Z0-9_.])*'/
+
+      whitespace = /[ \t\r\n]+/
+      comment = /\/\/[^\r\n]*/
+
+      state :common_rules do
+        rule %r/#{whitespace}/, Text
+        rule %r/#{comment}/, Comment::Single
+        rule %r/#{string}/, Literal::String
+        rule %r/#{float}/, Num::Float
+        rule %r/#{int}/, Num::Integer
+      end
+
+      state :root do
+        mixin :common_rules
+        rule %r/(#{lowercase_id})(\()/ do
+          groups Name::Function, Operator
+          push :event_type_params
+        end
+        rule %r/#{lowercase_id}/ do |m|
+          if m[0] == 'with'
+            token Keyword
+            push :data_expression_with
+          elsif self.class.keywords.include? m[0]
+            token Keyword
+          else
+            token Name::Function
+          end
+        end
+        rule %r/\(|\{|\[/, Operator, :event_type_params
+        rule %r/[_\|]/, Operator
+        rule %r/#{uppercase_id}/, Name::Class, :equation_block_expression
+        rule %r/;/, Operator
+      end
+
+      state :event_type_params do
+        mixin :common_rules
+        rule %r/\(|\{|\[/, Operator, :push
+        rule %r/\)|\}|\]/, Operator, :pop!
+        rule %r/#{lowercase_id}(?=:)/, Name::Entity
+        rule %r/(#{lowercase_id})/ do |m|
+          if self.class.keywords.include? m[0]
+            token Keyword
+          else
+            token Literal::String::Regex
+          end
+        end
+        rule %r/#{ellipsis}/, Literal::String::Symbol
+        rule %r/[_\|;,:]/, Operator
+      end
+
+      state :equation_block_expression do
+        mixin :common_rules
+        rule %r/[<,>]/, Operator
+        rule %r/#{lowercase_id}/, Literal::String::Regex
+        rule %r/=/ do
+          token Operator
+          goto :exp
+        end
+        rule %r/;/, Operator, :pop!
+      end
+
+      state :exp do
+        mixin :common_rules
+        rule %r/(if)(\()/ do
+          groups Keyword, Operator
+          push :data_expression
+        end
+        rule %r/let|var/, Keyword, :equation_block_expression
+        rule %r/(#{lowercase_id})(\()/ do
+          groups Name::Function, Operator
+          push :event_type_params
+        end
+        rule %r/(#{lowercase_id})/ do |m|
+          if self.class.keywords.include? m[0]
+            token Keyword
+          else
+            token Name::Function
+          end
+        end
+        rule %r/#{uppercase_id}(?=<)/, Name::Class, :data_expression
+        rule %r/#{uppercase_id}/, Name::Class
+        rule %r/[=(){}*+\/\\\|!>?]/, Operator
+        rule %r/;/, Operator, :pop!
+      end
+
+      state :data_expression do
+        mixin :common_rules
+        rule %r/#{lowercase_id}/ do |m|
+          if (self.class.arithmetic_keywords | self.class.keywords).include? m[0]
+            token Keyword
+          else
+            token Literal::String::Regex
+          end
+        end
+        rule %r/\(/, Operator, :push
+        rule %r/\)/, Operator, :pop!
+        rule %r/(>)(?=[^A-Z;]+[A-Z;>])/, Operator, :pop!
+        rule %r/[*^?!%&\[\]<>\|+=:,.\/\\_-]/, Operator
+        rule %r/;/, Operator, :pop!
+      end
+
+      state :data_expression_with do
+        mixin :common_rules
+        rule %r/>/, Operator
+        mixin :data_expression
+
+      end
+    end
+  end
+end

data/lib/rouge/lexers/toml.rb

@@ -5,10 +5,10 @@ module Rouge
   module Lexers
     class TOML < RegexLexer
       title "TOML"
-      desc 'the TOML configuration format (https://github.com/mojombo/toml)'
+      desc 'the TOML configuration format (https://github.com/toml-lang/toml)'
       tag 'toml'
 
-      filenames '*.toml', 'Pipfile'
+      filenames '*.toml', 'Pipfile', 'poetry.lock'
       mimetypes 'text/x-toml'
 
       # bare keys and quoted keys
@@ -24,8 +24,6 @@ module Rouge
           push :inline
         end
 
-        rule %r/(?<!=)\s*\[[\S]+\]/, Name::Namespace
-
         rule %r/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z/, Literal::Date
 
         rule %r/[+-]?\d+(?:_\d+)*\.\d+(?:_\d+)*(?:[eE][+-]?\d+(?:_\d+)*)?/, Num::Float
@@ -41,6 +39,8 @@ module Rouge
       state :root do
         mixin :basic
 
+        rule %r/(?<!=)\s*\[.*?\]+/, Name::Namespace
+
         rule %r/(#{identifier})(\s*)(=)/ do
           groups Name::Property, Text, Punctuation
           push :value

data/lib/rouge/lexers/tsx.rb

@@ -20,6 +20,13 @@ module Rouge
           groups Name::Other, Punctuation
           pop! 3
         end
+
+        rule %r/</, Punctuation, :type
+      end
+
+      state :type do
+        mixin :object
+        rule %r/>/, Punctuation, :pop!
       end
     end
   end

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

@@ -26,7 +26,10 @@ module Rouge
 
       def builtins
         @builtins ||= super + %w(
-          Pick Partial Readonly Record
+          Capitalize ConstructorParameters Exclude Extract InstanceType
+          Lowercase NonNullable Omit OmitThisParameter Parameters
+          Partial Pick Readonly Record Required
+          ReturnType ThisParameterType ThisType Uncapitalize Uppercase
         )
       end
 

data/lib/rouge/version.rb

@@ -3,6 +3,6 @@
 
 module Rouge
   def self.version
-    "3.30.0"
+    "4.0.0"
   end
 end

data/rouge.gemspec

@@ -16,7 +16,7 @@ Gem::Specification.new do |s|
   s.files = Dir['Gemfile', 'LICENSE', 'rouge.gemspec', 'lib/**/*.rb', 'lib/**/*.yml', 'bin/rougify', 'lib/rouge/demos/*']
   s.executables = %w(rougify)
   s.licenses = ['MIT', 'BSD-2-Clause']
-  s.required_ruby_version = '>= 2.0'
+  s.required_ruby_version = '>= 2.7'
   s.metadata = {
     "bug_tracker_uri"   => "https://github.com/rouge-ruby/rouge/issues",
     "changelog_uri"     => "https://github.com/rouge-ruby/rouge/blob/master/CHANGELOG.md",

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rouge
 version: !ruby/object:Gem::Version
-  version: 3.30.0
+  version: 4.0.0
 platform: ruby
 authors:
 - Jeanine Adkisson
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-07-30 00:00:00.000000000 Z
+date: 2022-09-06 00:00:00.000000000 Z
 dependencies: []
 description: Rouge aims to a be a simple, easy-to-extend drop-in replacement for pygments.
 email:
@@ -185,6 +185,7 @@ files:
 - lib/rouge/demos/reasonml
 - lib/rouge/demos/rego
 - lib/rouge/demos/rescript
+- lib/rouge/demos/rml
 - lib/rouge/demos/robot_framework
 - lib/rouge/demos/ruby
 - lib/rouge/demos/rust
@@ -201,7 +202,6 @@ files:
 - lib/rouge/demos/smalltalk
 - lib/rouge/demos/smarty
 - lib/rouge/demos/sml
-- lib/rouge/demos/solidity
 - lib/rouge/demos/sparql
 - lib/rouge/demos/sqf
 - lib/rouge/demos/sql
@@ -435,6 +435,7 @@ files:
 - lib/rouge/lexers/reasonml.rb
 - lib/rouge/lexers/rego.rb
 - lib/rouge/lexers/rescript.rb
+- lib/rouge/lexers/rml.rb
 - lib/rouge/lexers/robot_framework.rb
 - lib/rouge/lexers/ruby.rb
 - lib/rouge/lexers/rust.rb
@@ -452,7 +453,6 @@ files:
 - lib/rouge/lexers/smalltalk.rb
 - lib/rouge/lexers/smarty.rb
 - lib/rouge/lexers/sml.rb
-- lib/rouge/lexers/solidity.rb
 - lib/rouge/lexers/sparql.rb
 - lib/rouge/lexers/sqf.rb
 - lib/rouge/lexers/sqf/keywords.rb
@@ -534,7 +534,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.0'
+      version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/lib/rouge/demos/solidity

@@ -1,13 +0,0 @@
-pragma solidity ~0.4.15;
-
-interface IMirror {
-    function reflect() external payable returns(bool /* ain't I pretty?.. */);
-}
-
-contract Mirror is IMirror {
-    event logMessage(address indexed sender, uint256 value, uint256 gas, bytes data);
-
-    function () { // no funny stuff
-       revert();
-    }
-}

data/lib/rouge/lexers/solidity.rb

@@ -1,185 +0,0 @@
-# -*- coding: utf-8 -*- #
-
-module Rouge
-  module Lexers
-    class Solidity < RegexLexer
-      title "Solidity"
-      desc "Solidity, an Ethereum smart contract programming language"
-      tag 'solidity'
-      filenames '*.sol', '*.solidity'
-      mimetypes 'text/x-solidity'
-
-      # optional comment or whitespace
-      ws = %r((?:\s|//.*?\n|/[*].*?[*]/)+)
-      id = /[a-zA-Z$_][\w$_]*/
-
-      def self.detect?(text)
-        return true if text.start_with? 'pragma solidity'
-      end
-
-      # TODO: seperate by "type"
-      def self.keywords
-        @keywords ||= Set.new %w(
-          abstract anonymous as assembly break catch calldata constant
-          constructor continue contract do delete else emit enum event
-          external fallback for function hex if indexed interface
-          internal import is library mapping memory modifier new
-          override payable public pure pragma private receive return
-          returns storage struct throw try type using var view virtual
-          while
-        )
-      end
-
-      def self.builtins
-        return @builtins if @builtins
-
-        @builtins = Set.new %w(
-          now
-          false true
-          balance now selector super this
-          blockhash gasleft
-          assert require revert
-          selfdestruct suicide
-          call callcode delegatecall
-          send transfer
-          addmod ecrecover keccak256 mulmod sha256 sha3 ripemd160
-        )
-
-        # TODO: use (currently shadowed by catch-all in :statements)
-        abi = %w(decode encode encodePacked encodeWithSelector encodeWithSignature)
-        @builtins.merge( abi.map { |i| "abi.#{i}" } )
-        block = %w(coinbase difficulty gaslimit hash number timestamp)
-        @builtins.merge( block.map { |i| "block.#{i}" } )
-        msg = %w(data gas sender sig value)
-        @builtins.merge( msg.map { |i| "msg.#{i}" } )
-        tx = %w(gasprice origin)
-        @builtins.merge( tx.map { |i| "tx.#{i}" } )
-      end
-
-      def self.constants
-        @constants ||= Set.new %w(
-          wei finney szabo ether
-          seconds minutes hours days weeks years
-        )
-      end
-
-      def self.keywords_type
-        @keywords_type ||= Set.new %w(
-          address bool byte bytes int string uint
-        )
-      end
-
-      def self.reserved
-        @reserved ||= Set.new %w(
-          alias after apply auto case copyof default define final fixed
-          immutable implements in inline let macro match mutable null of
-          partial promise reference relocatable sealed sizeof static
-          supports switch typedef typeof ufixed unchecked
-        )
-      end
-
-      start { push :bol }
-
-      state :expr_bol do
-        mixin :inline_whitespace
-
-        rule(//) { pop! }
-      end
-
-      # :expr_bol is the same as :bol but without labels, since
-      # labels can only appear at the beginning of a statement.
-      state :bol do
-        mixin :expr_bol
-      end
-
-      # TODO: natspec in comments
-      state :inline_whitespace do
-        rule %r/[ \t\r]+/, Text
-        rule %r/\\\n/, Text # line continuation
-        rule %r(/\*), Comment::Multiline, :comment_multi
-      end
-
-      state :whitespace do
-        rule %r/\n+/m, Text, :bol
-        rule %r(//(\\.|.)*?\n), Comment::Single, :bol
-        mixin :inline_whitespace
-      end
-
-      state :expr_whitespace do
-        rule %r/\n+/m, Text, :expr_bol
-        mixin :whitespace
-      end
-
-      state :statements do
-        mixin :whitespace
-        rule %r/(hex)?\"/, Str, :string_double
-        rule %r/(hex)?\'/, Str, :string_single
-        rule %r('(\\.|\\[0-7]{1,3}|\\x[a-f0-9]{1,2}|[^\\'\n])')i, Str::Char
-        rule %r/\d\d*\.\d+([eE]\d+)?/i, Num::Float
-        rule %r/0x[0-9a-f]+/i, Num::Hex
-        rule %r/\d+([eE]\d+)?/i, Num::Integer
-        rule %r(\*/), Error
-        rule %r([~!%^&*+=\|?:<>/-]), Operator
-        rule %r/[()\[\],.]/, Punctuation
-        rule %r/u?fixed\d+x\d+/, Keyword::Reserved
-        rule %r/bytes\d+/, Keyword::Type
-        rule %r/u?int\d+/, Keyword::Type
-        rule id do |m|
-          name = m[0]
-
-          if self.class.keywords.include? name
-            token Keyword
-          elsif self.class.builtins.include? name
-            token Name::Builtin
-          elsif self.class.constants.include? name
-            token Keyword::Constant
-          elsif self.class.keywords_type.include? name
-            token Keyword::Type
-          elsif self.class.reserved.include? name
-            token Keyword::Reserved
-          else
-            token Name
-          end
-        end
-      end
-
-      state :root do
-        mixin :expr_whitespace
-        rule(//) { push :statement }
-        # TODO: function declarations
-      end
-
-      state :statement do
-        rule %r/;/, Punctuation, :pop!
-        mixin :expr_whitespace
-        mixin :statements
-        rule %r/[{}]/, Punctuation
-      end
-
-      state :string_common do
-        rule %r/\\(u[a-fA-F0-9]{4}|x..|[^x])/, Str::Escape
-        rule %r/[^\\\"\'\n]+/, Str
-        rule %r/\\\n/, Str # line continuation
-        rule %r/\\/, Str # stray backslash
-      end
-
-      state :string_double do
-        mixin :string_common
-        rule %r/\"/, Str, :pop!
-        rule %r/\'/, Str
-      end
-
-      state :string_single do
-        mixin :string_common
-        rule %r/\'/, Str, :pop!
-        rule %r/\"/, Str
-      end
-
-       state :comment_multi do
-         rule %r(\*/), Comment::Multiline, :pop!
-         rule %r([^*/]+), Comment::Multiline
-         rule %r([*/]), Comment::Multiline
-       end
-    end
-  end
-end