rouge 3.1.0 → 3.18.0

data/lib/rouge/lexers/nim.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers
@@ -111,7 +112,7 @@ module Rouge
              Punctuation)
 
         # Strings
-        rule(/(?:[\w]+)"/,Str, :rdqs)
+        rule(/(?:\w+)"/,Str, :rdqs)
         rule(/"""/,       Str, :tdqs)
         rule(/"/,         Str, :dqs)
 
@@ -132,11 +133,12 @@ module Rouge
         # Numbers
         # Note: Have to do this with a block to push multiple states first,
         #       since we can't pass array of states like w/ Pygments.
-        rule(/[0-9][0-9_]*(?=([eE.]|'?[fF](32|64)))/) do |number|
+        rule(/[0-9][0-9_]*(?=([eE.]|'?[fF](32|64)))/) do
          push :floatsuffix
          push :floatnumber
          token Num::Float
         end
+
         rule(/0[xX][a-fA-F0-9][a-fA-F0-9_]*/, Num::Hex,     :intsuffix)
         rule(/0[bB][01][01_]*/,               Num,          :intsuffix)
         rule(/0o[0-7][0-7_]*/,                Num::Oct,     :intsuffix)

data/lib/rouge/lexers/nix.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers
@@ -10,34 +11,34 @@ module Rouge
       filenames '*.nix'
 
       state :whitespaces do
-        rule /^\s*\n\s*$/m, Text
-        rule /\s+/, Text
+        rule %r/^\s*\n\s*$/m, Text
+        rule %r/\s+/, Text
       end
 
       state :comment do
-        rule /#.*$/, Comment
-        rule /\/\*/, Comment, :multiline_comment
+        rule %r/#.*$/, Comment
+        rule %r(/\*), Comment, :multiline_comment
       end
 
       state :multiline_comment do
-        rule /\*\//, Comment, :pop!
-        rule /./, Comment
+        rule %r(\*/), Comment, :pop!
+        rule %r/./, Comment
       end
 
       state :number do
-        rule /[0-9]/, Num::Integer
+        rule %r/[0-9]/, Num::Integer
       end
 
       state :null do
-        rule /(null)/, Keyword::Constant
+        rule %r/(null)/, Keyword::Constant
       end
 
       state :boolean do
-        rule /(true|false)/, Keyword::Constant
+        rule %r/(true|false)/, Keyword::Constant
       end
 
       state :binding do
-        rule /[a-zA-Z_][a-zA-Z0-9-]*/, Name::Variable
+        rule %r/[a-zA-Z_][a-zA-Z0-9-]*/, Name::Variable
       end
 
       state :path do
@@ -48,84 +49,89 @@ module Rouge
         tilde = /~#{section}+/.source
         basic = /#{word}(\/#{word})+/.source
         url = /#{prefix}(\/?#{basic})/.source
-        rule /(#{root}|#{tilde}|#{basic}|#{url})/, Str::Other
+        rule %r/(#{root}|#{tilde}|#{basic}|#{url})/, Str::Other
       end
 
       state :string do
-        rule /"/, Str::Double, :string_double_quoted
-        rule /''/, Str::Double, :string_indented
+        rule %r/"/, Str::Double, :double_quoted_string
+        rule %r/''/, Str::Double, :indented_string
       end
 
       state :string_content do
-        rule /\${/, Str::Interpol, :string_interpolated_arg
-        mixin :escaped_sequence
+        rule %r/\\./, Str::Escape
+        rule %r/\$\$/, Str::Escape
+        rule %r/\${/, Str::Interpol, :string_interpolated_arg
       end
 
-      state :escaped_sequence do
-        rule /\\./, Str::Escape
+      state :indented_string_content do
+        rule %r/'''/, Str::Escape
+        rule %r/''\$/, Str::Escape
+        rule %r/\$\$/, Str::Escape
+        rule %r/''\\./, Str::Escape
+        rule %r/\${/, Str::Interpol, :string_interpolated_arg
       end
 
       state :string_interpolated_arg do
         mixin :expression
-        rule /}/, Str::Interpol, :pop!
+        rule %r/}/, Str::Interpol, :pop!
       end
 
-      state :string_indented do
-        mixin :string_content
-        rule /''/, Str::Double, :pop!
-        rule /./, Str::Double
+      state :indented_string do
+        mixin :indented_string_content
+        rule %r/''/, Str::Double, :pop!
+        rule %r/./, Str::Double
       end
 
-      state :string_double_quoted do
+      state :double_quoted_string do
         mixin :string_content
-        rule /"/, Str::Double, :pop!
-        rule /./, Str::Double
+        rule %r/"/, Str::Double, :pop!
+        rule %r/./, Str::Double
       end
 
       state :operator do
-        rule /(\.|\?|\+\+|\+|!=|!|\/\/|\=\=|&&|\|\||->|\/|\*|-|<|>|<=|=>)/, Operator
+        rule %r/(\.|\?|\+\+|\+|!=|!|\/\/|\=\=|&&|\|\||->|\/|\*|-|<|>|<=|=>)/, Operator
       end
 
       state :assignment do
-        rule /(=)/, Operator
-        rule /(@)/, Operator
+        rule %r/(=)/, Operator
+        rule %r/(@)/, Operator
       end
 
       state :accessor do
-        rule /(\$)/, Punctuation
+        rule %r/(\$)/, Punctuation
       end
 
       state :delimiter do
-        rule /(;|,|:)/, Punctuation
+        rule %r/(;|,|:)/, Punctuation
       end
 
       state :atom_content do
         mixin :expression
-        rule /\)/, Punctuation, :pop!
+        rule %r/\)/, Punctuation, :pop!
       end
 
       state :atom do
-        rule /\(/, Punctuation, :atom_content
+        rule %r/\(/, Punctuation, :atom_content
       end
 
       state :list do
-        rule /\[/, Punctuation, :list_content
+        rule %r/\[/, Punctuation, :list_content
       end
 
       state :list_content do
-        rule /\]/, Punctuation, :pop!
+        rule %r/\]/, Punctuation, :pop!
         mixin :expression
       end
 
       state :set do
-        rule /{/, Punctuation, :set_content
+        rule %r/{/, Punctuation, :set_content
       end
 
       state :set_content do
-        rule /}/, Punctuation, :pop!
+        rule %r/}/, Punctuation, :pop!
         mixin :expression
       end
-      
+
       state :expression do
         mixin :ignore
         mixin :comment
@@ -155,22 +161,22 @@ module Rouge
 
       state :keywords_namespace do
         keywords = %w(with in inherit)
-        rule /(?:#{keywords.join('|')})\b/, Keyword::Namespace
+        rule %r/(?:#{keywords.join('|')})\b/, Keyword::Namespace
       end
 
       state :keywords_declaration do
         keywords = %w(let)
-        rule /(?:#{keywords.join('|')})\b/, Keyword::Declaration
+        rule %r/(?:#{keywords.join('|')})\b/, Keyword::Declaration
       end
 
       state :keywords_conditional do
         keywords = %w(if then else)
-        rule /(?:#{keywords.join('|')})\b/, Keyword
+        rule %r/(?:#{keywords.join('|')})\b/, Keyword
       end
 
       state :keywords_reserved do
         keywords = %w(rec assert map)
-        rule /(?:#{keywords.join('|')})\b/, Keyword::Reserved
+        rule %r/(?:#{keywords.join('|')})\b/, Keyword::Reserved
       end
 
       state :keywords_builtin do
@@ -186,7 +192,7 @@ module Rouge
           throw
           toString
         )
-        rule /(?:#{keywords.join('|')})\b/, Keyword::Reserved
+        rule %r/(?:#{keywords.join('|')})\b/, Keyword::Reserved
       end
 
       state :ignore do

data/lib/rouge/lexers/objective_c.rb

@@ -1,194 +1,21 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers
     load_lexer 'c.rb'
+    load_lexer 'objective_c/common.rb'
 
     class ObjectiveC < C
+      extend ObjectiveCCommon
+
       tag 'objective_c'
       title "Objective-C"
       desc 'an extension of C commonly used to write Apple software'
-      aliases 'objc'
+      aliases 'objc', 'obj-c', 'obj_c', 'objectivec'
       filenames '*.m', '*.h'
 
       mimetypes 'text/x-objective_c', 'application/x-objective_c'
-
-      def self.at_keywords
-        @at_keywords ||= %w(
-          selector private protected public encode synchronized try
-          throw catch finally end property synthesize dynamic optional
-          interface implementation import
-        )
-      end
-
-      def self.at_builtins
-        @at_builtins ||= %w(true false YES NO)
-      end
-
-      def self.builtins
-        @builtins ||= %w(YES NO nil)
-      end
-
-      id = /[a-z$_][a-z0-9$_]*/i
-
-      prepend :statements do
-        rule /@"/, Str, :string
-        rule /@'(\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,2}|\\.|[^\\'\n]')/,
-          Str::Char
-        rule /@(\d+[.]\d*|[.]\d+|\d+)e[+-]?\d+l?/i,
-          Num::Float
-        rule /@(\d+[.]\d*|[.]\d+|\d+f)f?/i, Num::Float
-        rule /@0x\h+[lL]?/, Num::Hex
-        rule /@0[0-7]+l?/i, Num::Oct
-        rule /@\d+l?/, Num::Integer
-        rule /\bin\b/, Keyword
-
-        rule /@(?:interface|implementation)\b/ do
-          token Keyword
-          goto :classname
-        end
-
-        rule /@(?:class|protocol)\b/ do
-          token Keyword
-          goto :forward_classname
-        end
-
-        rule /@([[:alnum:]]+)/ do |m|
-          if self.class.at_keywords.include? m[1]
-            token Keyword
-          elsif self.class.at_builtins.include? m[1]
-            token Name::Builtin
-          else
-            token Error
-          end
-        end
-
-        rule /[?]/, Punctuation, :ternary
-        rule /\[/,  Punctuation, :message
-        rule /@\[/, Punctuation, :array_literal
-        rule /@\{/, Punctuation, :dictionary_literal
-      end
-
-      state :ternary do
-        rule /:/, Punctuation, :pop!
-        mixin :statements
-      end
-
-      state :message_shared do
-        rule /\]/, Punctuation, :pop!
-        rule /\{/, Punctuation, :pop!
-        rule /;/, Error
-
-        mixin :statement
-      end
-
-      state :message do
-        rule /(#{id})(\s*)(:)/ do
-          groups(Name::Function, Text, Punctuation)
-          goto :message_with_args
-        end
-
-        rule /(#{id})(\s*)(\])/ do
-          groups(Name::Function, Text, Punctuation)
-          pop!
-        end
-
-        mixin :message_shared
-      end
-
-      state :message_with_args do
-        rule /\{/, Punctuation, :function
-        rule /(#{id})(\s*)(:)/ do
-          groups(Name::Function, Text, Punctuation)
-          pop!
-        end
-
-        mixin :message_shared
-      end
-
-      state :array_literal do
-        rule /]/, Punctuation, :pop!
-        rule /,/, Punctuation
-        mixin :statements
-      end
-
-      state :dictionary_literal do
-        rule /}/, Punctuation, :pop!
-        rule /,/, Punctuation
-        mixin :statements
-      end
-
-      state :classname do
-        mixin :whitespace
-
-        rule /(#{id})(\s*)(:)(\s*)(#{id})/ do
-          groups(Name::Class, Text,
-                 Punctuation, Text,
-                 Name::Class)
-          pop!
-        end
-
-        rule /(#{id})(\s*)([(])(\s*)(#{id})(\s*)([)])/ do
-          groups(Name::Class, Text,
-                 Punctuation, Text,
-                 Name::Label, Text,
-                 Punctuation)
-          pop!
-        end
-
-        rule id, Name::Class, :pop!
-      end
-
-      state :forward_classname do
-        mixin :whitespace
-
-        rule /(#{id})(\s*)(,)(\s*)/ do
-          groups(Name::Class, Text, Punctuation, Text)
-          push
-        end
-
-        rule /(#{id})(\s*)(;?)/ do
-          groups(Name::Class, Text, Punctuation)
-          pop!
-        end
-      end
-
-      prepend :root do
-        rule %r(
-          ([-+])(\s*)
-          ([(].*?[)])?(\s*)
-          (?=#{id}:?)
-        )ix do |m|
-          token Keyword, m[1]; token Text, m[2]
-          recurse m[3]; token Text, m[4]
-          push :method_definition
-        end
-      end
-
-      state :method_definition do
-        rule /,/, Punctuation
-        rule /[.][.][.]/, Punctuation
-        rule /([(].*?[)])(#{id})/ do |m|
-          recurse m[1]; token Name::Variable, m[2]
-        end
-
-        rule /(#{id})(\s*)(:)/m do
-          groups(Name::Function, Text, Punctuation)
-        end
-
-        rule /;/, Punctuation, :pop!
-
-        rule /{/ do
-          token Punctuation
-          goto :function
-        end
-
-        mixin :inline_whitespace
-        rule %r(//.*?\n), Comment::Single
-        rule /\s+/m, Text
-
-        rule(//) { pop! }
-      end
     end
   end
 end

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

@@ -0,0 +1,184 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    module ObjectiveCCommon
+      id = /[a-z$_][a-z0-9$_]*/i
+
+      def at_keywords
+        @at_keywords ||= %w(
+          selector private protected public encode synchronized try
+          throw catch finally end property synthesize dynamic optional
+          interface implementation import autoreleasepool
+        )
+      end
+
+      def at_builtins
+        @at_builtins ||= %w(true false YES NO)
+      end
+
+      def builtins
+        @builtins ||= %w(YES NO nil)
+      end
+
+      def self.extended(base)
+        base.prepend :statements do
+          rule %r/@"/, base::Str, :string
+          rule %r/@'(\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,2}|\\.|[^\\'\n]')/,
+            base::Str::Char
+          rule %r/@(\d+[.]\d*|[.]\d+|\d+)e[+-]?\d+l?/i,
+            base::Num::Float
+          rule %r/@(\d+[.]\d*|[.]\d+|\d+f)f?/i, base::Num::Float
+          rule %r/@0x\h+[lL]?/, base::Num::Hex
+          rule %r/@0[0-7]+l?/i, base::Num::Oct
+          rule %r/@\d+l?/, base::Num::Integer
+          rule %r/\bin\b/, base::Keyword
+
+          rule %r/@(?:interface|implementation)\b/, base::Keyword, :objc_classname
+          rule %r/@(?:class|protocol)\b/, base::Keyword, :forward_classname
+
+          rule %r/@([[:alnum:]]+)/ do |m|
+            if base.at_keywords.include? m[1]
+              token base::Keyword
+            elsif base.at_builtins.include? m[1]
+              token base::Name::Builtin
+            else
+              token base::Error
+            end
+          end
+
+          rule %r/[?]/, base::Punctuation, :ternary
+          rule %r/\[/,  base::Punctuation, :message
+          rule %r/@\[/, base::Punctuation, :array_literal
+          rule %r/@\{/, base::Punctuation, :dictionary_literal
+        end
+
+        id = /[a-z$_][a-z0-9$_]*/i
+
+        base.state :ternary do
+          rule %r/:/, base::Punctuation, :pop!
+          mixin :statements
+        end
+
+        base.state :message_shared do
+          rule %r/\]/, base::Punctuation, :pop!
+          rule %r/\{/, base::Punctuation, :pop!
+          rule %r/;/, base::Error
+
+          mixin :statements
+        end
+
+        base.state :message do
+          rule %r/(#{id})(\s*)(:)/ do
+            groups(base::Name::Function, base::Text, base::Punctuation)
+            goto :message_with_args
+          end
+
+          rule %r/(#{id})(\s*)(\])/ do
+            groups(base::Name::Function, base::Text, base::Punctuation)
+            pop!
+          end
+
+          mixin :message_shared
+        end
+
+        base.state :message_with_args do
+          rule %r/\{/, base::Punctuation, :function
+          rule %r/(#{id})(\s*)(:)/ do
+            groups(base::Name::Function, base::Text, base::Punctuation)
+            pop!
+          end
+
+          mixin :message_shared
+        end
+
+        base.state :array_literal do
+          rule %r/]/, base::Punctuation, :pop!
+          rule %r/,/, base::Punctuation
+          mixin :statements
+        end
+
+        base.state :dictionary_literal do
+          rule %r/}/, base::Punctuation, :pop!
+          rule %r/,/, base::Punctuation
+          mixin :statements
+        end
+
+        base.state :objc_classname do
+          mixin :whitespace
+
+          rule %r/(#{id})(\s*)(:)(\s*)(#{id})/ do
+            groups(base::Name::Class, base::Text,
+                   base::Punctuation, base::Text,
+                   base::Name::Class)
+            pop!
+          end
+
+          rule %r/(#{id})(\s*)([(])(\s*)(#{id})(\s*)([)])/ do
+            groups(base::Name::Class, base::Text,
+                   base::Punctuation, base::Text,
+                   base::Name::Label, base::Text,
+                   base::Punctuation)
+            pop!
+          end
+
+          rule id, base::Name::Class, :pop!
+        end
+
+        base.state :forward_classname do
+          mixin :whitespace
+
+          rule %r/(#{id})(\s*)(,)(\s*)/ do
+            groups(base::Name::Class, base::Text, base::Punctuation, base::Text)
+            push
+          end
+
+          rule %r/(#{id})(\s*)(;?)/ do
+            groups(base::Name::Class, base::Text, base::Punctuation)
+            pop!
+          end
+        end
+
+        base.prepend :root do
+          rule %r(
+            ([-+])(\s*)
+            ([(].*?[)])?(\s*)
+            (?=#{id}:?)
+          )ix do |m|
+            token base::Keyword, m[1]
+            token base::Text, m[2]
+            recurse(m[3]) if m[3]
+            token base::Text, m[4]
+            push :method_definition
+          end
+        end
+
+        base.state :method_definition do
+          rule %r/,/, base::Punctuation
+          rule %r/[.][.][.]/, base::Punctuation
+          rule %r/([(].*?[)])(#{id})/ do |m|
+            recurse m[1]; token base::Name::Variable, m[2]
+          end
+
+          rule %r/(#{id})(\s*)(:)/m do
+            groups(base::Name::Function, base::Text, base::Punctuation)
+          end
+
+          rule %r/;/, base::Punctuation, :pop!
+
+          rule %r/{/ do
+            token base::Punctuation
+            goto :function
+          end
+
+          mixin :inline_whitespace
+          rule %r(//.*?\n), base::Comment::Single
+          rule %r/\s+/m, base::Text
+
+          rule(//) { pop! }
+        end
+      end
+    end
+  end
+end