rouge 3.4.1 → 3.6.0

data/lib/rouge/guessers/glob_mapping.rb

@@ -32,7 +32,7 @@ module Rouge
         basename = File.basename(filename)
 
         collect_best(lexers) do |lexer|
-          score = (@glob_map[lexer.name] || []).map do |pattern|
+          (@glob_map[lexer.name] || []).map do |pattern|
             if test_glob(pattern, basename)
               # specificity is better the fewer wildcards there are
               -pattern.scan(/[*?\[]/).size

data/lib/rouge/guessers/modeline.rb

@@ -37,7 +37,7 @@ module Rouge
 
         matches = MODELINES.map { |re| re.match(search_space) }.compact
         return lexers unless matches.any?
-        
+
         match_set = Set.new(matches.map { |m| m[1] })
         lexers.select { |l| match_set.include?(l.tag) || l.aliases.any? { |a| match_set.include?(a) } }
       end

data/lib/rouge/lexer.rb

@@ -114,7 +114,7 @@ module Rouge
       def demo_file(arg=:absent)
         return @demo_file = Pathname.new(arg) unless arg == :absent
 
-        @demo_file = Pathname.new(__FILE__).dirname.join('demos', tag)
+        @demo_file = Pathname.new(File.join(__dir__, 'demos', tag))
       end
 
       # Specify or get a small demo string for this lexer
@@ -196,7 +196,7 @@ module Rouge
       end
 
       def disable_debug!
-        remove_instance_variable :@debug_enabled
+        remove_instance_variable :@debug_enabled if defined? @debug_enabled
       end
 
       def debug_enabled?
@@ -213,7 +213,7 @@ module Rouge
       # @private
       def register(name, lexer)
         # reset an existing list of lexers
-        @all = nil if @all
+        @all = nil if defined?(@all)
         registry[name.to_s] = lexer
       end
 
@@ -421,17 +421,29 @@ module Rouge
     # @option opts :continue
     #   Continue the lex from the previous state (i.e. don't call #reset!)
     #
-    # @note The use of `opts` has been deprecated. A warning is issued if run
-    #   with `$VERBOSE` set to true.
-    def lex(string, opts={}, &b)
-      unless opts.nil?
-        warn 'The use of opts with Lexer.lex is deprecated' if $VERBOSE
+    # @note The use of :continue => true has been deprecated. A warning is
+    #       issued if run with `$VERBOSE` set to true.
+    #
+    # @note The use of arbitrary `opts` has never been supported, but we
+    #       previously ignored them with no error. We now warn unconditionally.
+    def lex(string, opts=nil, &b)
+      if opts
+        if (opts.keys - [:continue]).size > 0
+          # improper use of options hash
+          warn('Improper use of Lexer#lex - this method does not receive options.' +
+               ' This will become an error in a future version.')
+        end
+
+        if opts[:continue]
+          warn '`lex :continue => true` is deprecated, please use #continue_lex instead'
+          return continue_lex(string, &b)
+        end
       end
 
-      return enum_for(:lex, string, opts) unless block_given?
+      return enum_for(:lex, string) unless block_given?
 
       Lexer.assert_utf8!(string)
-      reset! unless opts[:continue]
+      reset!
 
       continue_lex(string, &b)
     end

data/lib/rouge/lexers/abap.rb

@@ -182,16 +182,16 @@ module Rouge
       end
 
       state :root do
-        rule /\s+/m, Text
+        rule %r/\s+/m, Text
 
-        rule /".*/, Comment::Single
+        rule %r/".*/, Comment::Single
         rule %r(^\*.*), Comment::Multiline
-        rule /\d+/, Num::Integer
-        rule /('|`)/, Str::Single, :single_string
-        rule /[\[\]\(\)\{\}\[\]\.,:\|]/, Punctuation
+        rule %r/\d+/, Num::Integer
+        rule %r/('|`)/, Str::Single, :single_string
+        rule %r/[\[\]\(\)\{\}\.,:\|]/, Punctuation
 
         # builtins / new ABAP 7.40 keywords (@DATA(), ...)
-        rule /(->|=>)?([A-Za-z][A-Za-z0-9_\-]*)(\()/ do |m|
+        rule %r/(->|=>)?([A-Za-z][A-Za-z0-9_\-]*)(\()/ do |m|
           if m[1] != ''
             token Operator, m[1]
           end
@@ -207,7 +207,7 @@ module Rouge
         end
 
         # keywords, types and normal text
-        rule /\w[\w\d]*/ do |m|
+        rule %r/\w\w*/ do |m|
           if self.class.keywords.include? m[0].upcase
             token Keyword
           elsif self.class.types.include? m[0].downcase
@@ -229,10 +229,10 @@ module Rouge
       end
 
       state :single_string do
-        rule /\\./, Str::Escape
-        rule /(''|``)/, Str::Escape
-        rule /['`]/, Str::Single, :pop!
-        rule /[^\\'`]+/, Str::Single
+        rule %r/\\./, Str::Escape
+        rule %r/(''|``)/, Str::Escape
+        rule %r/['`]/, Str::Single, :pop!
+        rule %r/[^\\'`]+/, Str::Single
       end
 
     end

data/lib/rouge/lexers/actionscript.rb

@@ -13,7 +13,7 @@ module Rouge
       mimetypes 'application/x-actionscript'
 
       state :comments_and_whitespace do
-        rule /\s+/, Text
+        rule %r/\s+/, Text
         rule %r(//.*?$), Comment::Single
         rule %r(/\*.*?\*/)m, Comment::Multiline
       end
@@ -26,9 +26,9 @@ module Rouge
           goto :regex
         end
 
-        rule /[{]/, Punctuation, :object
+        rule %r/[{]/, Punctuation, :object
 
-        rule //, Text, :pop!
+        rule %r//, Text, :pop!
       end
 
       state :regex do
@@ -39,38 +39,38 @@ module Rouge
 
         rule %r([^/]\n), Error, :pop!
 
-        rule /\n/, Error, :pop!
-        rule /\[\^/, Str::Escape, :regex_group
-        rule /\[/, Str::Escape, :regex_group
-        rule /\\./, Str::Escape
+        rule %r/\n/, Error, :pop!
+        rule %r/\[\^/, Str::Escape, :regex_group
+        rule %r/\[/, Str::Escape, :regex_group
+        rule %r/\\./, Str::Escape
         rule %r{[(][?][:=<!]}, Str::Escape
-        rule /[{][\d,]+[}]/, Str::Escape
-        rule /[()?]/, Str::Escape
-        rule /./, Str::Regex
+        rule %r/[{][\d,]+[}]/, Str::Escape
+        rule %r/[()?]/, Str::Escape
+        rule %r/./, Str::Regex
       end
 
       state :regex_end do
-        rule /[gim]+/, Str::Regex, :pop!
+        rule %r/[gim]+/, Str::Regex, :pop!
         rule(//) { pop! }
       end
 
       state :regex_group do
         # specially highlight / in a group to indicate that it doesn't
         # close the regex
-        rule /\//, Str::Escape
+        rule %r(/), Str::Escape
 
         rule %r([^/]\n) do
           token Error
           pop! 2
         end
 
-        rule /\]/, Str::Escape, :pop!
-        rule /\\./, Str::Escape
-        rule /./, Str::Regex
+        rule %r/\]/, Str::Escape, :pop!
+        rule %r/\\./, Str::Escape
+        rule %r/./, Str::Regex
       end
 
       state :bad_regex do
-        rule /[^\n]+/, Error, :pop!
+        rule %r/[^\n]+/, Error, :pop!
       end
 
       def self.keywords
@@ -109,25 +109,25 @@ module Rouge
       id = /[$a-zA-Z_][a-zA-Z0-9_]*/
 
       state :root do
-        rule /\A\s*#!.*?\n/m, Comment::Preproc, :statement
-        rule /\n/, Text, :statement
+        rule %r/\A\s*#!.*?\n/m, Comment::Preproc, :statement
+        rule %r/\n/, Text, :statement
         rule %r((?<=\n)(?=\s|/|<!--)), Text, :expr_start
         mixin :comments_and_whitespace
         rule %r(\+\+ | -- | ~ | && | \|\| | \\(?=\n) | << | >>>? | ===
                | !== )x,
           Operator, :expr_start
         rule %r([:-<>+*%&|\^/!=]=?), Operator, :expr_start
-        rule /[(\[,]/, Punctuation, :expr_start
-        rule /;/, Punctuation, :statement
-        rule /[)\].]/, Punctuation
+        rule %r/[(\[,]/, Punctuation, :expr_start
+        rule %r/;/, Punctuation, :statement
+        rule %r/[)\].]/, Punctuation
 
-        rule /[?]/ do
+        rule %r/[?]/ do
           token Punctuation
           push :ternary
           push :expr_start
         end
 
-        rule /[{}]/, Punctuation, :statement
+        rule %r/[{}]/, Punctuation, :statement
 
         rule id do |m|
           if self.class.keywords.include? m[0]
@@ -147,20 +147,20 @@ module Rouge
           end
         end
 
-        rule /\-?[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?/, Num::Float
-        rule /0x[0-9a-fA-F]+/, Num::Hex
-        rule /\-?[0-9]+/, Num::Integer
-        rule /"(\\\\|\\"|[^"])*"/, Str::Double
-        rule /'(\\\\|\\'|[^'])*'/, Str::Single
+        rule %r/\-?[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?/, Num::Float
+        rule %r/0x[0-9a-fA-F]+/, Num::Hex
+        rule %r/\-?[0-9]+/, Num::Integer
+        rule %r/"(\\\\|\\"|[^"])*"/, Str::Double
+        rule %r/'(\\\\|\\'|[^'])*'/, Str::Single
       end
 
       # braced parts that aren't object literals
       state :statement do
-        rule /(#{id})(\s*)(:)/ do
+        rule %r/(#{id})(\s*)(:)/ do
           groups Name::Label, Text, Punctuation
         end
 
-        rule /[{}]/, Punctuation
+        rule %r/[{}]/, Punctuation
 
         mixin :expr_start
       end
@@ -168,23 +168,23 @@ module Rouge
       # object literals
       state :object do
         mixin :comments_and_whitespace
-        rule /[}]/ do
+        rule %r/[}]/ do
           token Punctuation
           goto :statement
         end
 
-        rule /(#{id})(\s*)(:)/ do
+        rule %r/(#{id})(\s*)(:)/ do
           groups Name::Attribute, Text, Punctuation
           push :expr_start
         end
 
-        rule /:/, Punctuation
+        rule %r/:/, Punctuation
         mixin :root
       end
 
       # ternary expressions, where <id>: is not a label!
       state :ternary do
-        rule /:/ do
+        rule %r/:/ do
           token Punctuation
           goto :expr_start
         end

data/lib/rouge/lexers/apache.rb

@@ -15,7 +15,7 @@ module Rouge
         attr_reader :keywords
       end
       # Load Apache keywords from separate YML file
-      @keywords = ::YAML.load_file(Pathname.new(__FILE__).dirname.join('apache/keywords.yml')).tap do |h|
+      @keywords = ::YAML.load_file(File.join(__dir__, 'apache/keywords.yml')).tap do |h|
         h.each do |k,v|
           h[k] = Set.new v
         end
@@ -30,19 +30,19 @@ module Rouge
       end
 
       state :whitespace do
-        rule /\#.*/, Comment
-        rule /\s+/m, Text
+        rule %r/\#.*/, Comment
+        rule %r/\s+/m, Text
       end
 
       state :root do
         mixin :whitespace
 
-        rule /(<\/?)(\w+)/ do |m|
+        rule %r/(<\/?)(\w+)/ do |m|
           groups Punctuation, name_for_token(m[2].downcase, :sections, Name::Label)
           push :section
         end
 
-        rule /\w+/ do |m|
+        rule %r/\w+/ do |m|
           token name_for_token(m[0].downcase, :directives, Name::Class)
           push :directive
         end
@@ -50,7 +50,7 @@ module Rouge
 
       state :section do
         # Match section arguments
-        rule /([^>]+)?(>(?:\r\n?|\n)?)/ do |m|
+        rule %r/([^>]+)?(>(?:\r\n?|\n)?)/ do
           groups Literal::String::Regex, Punctuation
           pop!
         end
@@ -60,11 +60,11 @@ module Rouge
 
       state :directive do
         # Match value literals and other directive arguments
-        rule /\r\n?|\n/, Text, :pop!
+        rule %r/\r\n?|\n/, Text, :pop!
 
         mixin :whitespace
 
-        rule /\S+/ do |m|
+        rule %r/\S+/ do |m|
           token name_for_token(m[0], :values, Literal::String::Symbol)
         end
       end

data/lib/rouge/lexers/apple_script.rb

@@ -319,28 +319,28 @@ module Rouge
       identifiers = %r(\b([a-zA-Z]\w*)\b)
 
       state :root do
-        rule /\s+/, Text::Whitespace
-        rule /¬\n/, Literal::String::Escape
-        rule /'s\s+/, Text
-        rule /(--|#).*?$/, Comment::Single
-        rule /\(\*/, Comment::Multiline
-        rule /[\(\){}!,.:]/, Punctuation
-        rule /(«)([^»]+)(»)/ do |match|
+        rule %r/\s+/, Text::Whitespace
+        rule %r/¬\n/, Literal::String::Escape
+        rule %r/'s\s+/, Text
+        rule %r/(--|#).*?$/, Comment::Single
+        rule %r/\(\*/, Comment::Multiline
+        rule %r/[\(\){}!,.:]/, Punctuation
+        rule %r/(«)([^»]+)(»)/ do |match|
           token Text, match[1]
           token Name::Builtin, match[2]
           token Text, match[3]
         end
-        rule /\b((?:considering|ignoring)\s*)(application responses|case|diacriticals|hyphens|numeric strings|punctuation|white space)/ do |match|
+        rule %r/\b((?:considering|ignoring)\s*)(application responses|case|diacriticals|hyphens|numeric strings|punctuation|white space)/ do |match|
           token Keyword, match[1]
           token Name::Builtin, match[2]
         end
-        rule /(-|\*|\+|&|≠|>=?|<=?|=|≥|≤|\/|÷|\^)/, Operator
+        rule %r/(-|\*|\+|&|≠|>=?|<=?|=|≥|≤|\/|÷|\^)/, Operator
         rule operators, Operator::Word
-        rule /^(\s*(?:on|end)\s+)'r'(%s)/ do |match|
+        rule %r/^(\s*(?:on|end)\s+)'r'(%s)/ do |match|
           token Keyword, match[1]
           token Name::Function, match[2]
         end
-        rule /^(\s*)(in|on|script|to)(\s+)/ do |match|
+        rule %r/^(\s*)(in|on|script|to)(\s+)/ do |match|
           token Text, match[1]
           token Keyword, match[2]
           token Text, match[3]
@@ -349,6 +349,7 @@ module Rouge
           token Keyword, match[1]
           token Name::Class, match[2]
         end
+        rule literals, Name::Builtin
         rule commands, Name::Builtin
         rule controls, Keyword
         rule declarations, Keyword
@@ -359,10 +360,10 @@ module Rouge
         rule studio_classes, Name::Builtin
         rule studio_commands, Name::Builtin
         rule references, Name::Builtin
-        rule /"(\\\\|\\"|[^"])*"/, Literal::String::Double
+        rule %r/"(\\\\|\\"|[^"])*"/, Literal::String::Double
         rule identifiers, Name::Variable
-        rule /[-+]?(\d+\.\d*|\d*\.\d+)(E[-+][0-9]+)?/, Literal::Number::Float
-        rule /[-+]?\d+/, Literal::Number::Integer
+        rule %r/[-+]?(\d+\.\d*|\d*\.\d+)(E[-+][0-9]+)?/, Literal::Number::Float
+        rule %r/[-+]?\d+/, Literal::Number::Integer
       end
     end
   end

data/lib/rouge/lexers/awk.rb

@@ -47,7 +47,7 @@ module Rouge
       end
 
       state :comments_and_whitespace do
-        rule /\s+/, Text
+        rule %r/\s+/, Text
         rule %r(#.*?$), Comment::Single
       end
 
@@ -57,7 +57,7 @@ module Rouge
           token Str::Regex
           goto :regex
         end
-        rule //, Text, :pop!
+        rule %r//, Text, :pop!
       end
 
       state :regex do
@@ -68,14 +68,14 @@ module Rouge
 
         rule %r([^/]\n), Error, :pop!
 
-        rule /\n/, Error, :pop!
-        rule /\[\^/, Str::Escape, :regex_group
-        rule /\[/, Str::Escape, :regex_group
-        rule /\\./, Str::Escape
+        rule %r/\n/, Error, :pop!
+        rule %r/\[\^/, Str::Escape, :regex_group
+        rule %r/\[/, Str::Escape, :regex_group
+        rule %r/\\./, Str::Escape
         rule %r{[(][?][:=<!]}, Str::Escape
-        rule /[{][\d,]+[}]/, Str::Escape
-        rule /[()?]/, Str::Escape
-        rule /./, Str::Regex
+        rule %r/[{][\d,]+[}]/, Str::Escape
+        rule %r/[()?]/, Str::Escape
+        rule %r/./, Str::Regex
       end
 
       state :regex_end do
@@ -85,20 +85,20 @@ module Rouge
       state :regex_group do
         # specially highlight / in a group to indicate that it doesn't
         # close the regex
-        rule /\//, Str::Escape
+        rule %r(/), Str::Escape
 
         rule %r([^/]\n) do
           token Error
           pop! 2
         end
 
-        rule /\]/, Str::Escape, :pop!
-        rule /\\./, Str::Escape
-        rule /./, Str::Regex
+        rule %r/\]/, Str::Escape, :pop!
+        rule %r/\\./, Str::Escape
+        rule %r/./, Str::Regex
       end
 
       state :bad_regex do
-        rule /[^\n]+/, Error, :pop!
+        rule %r/[^\n]+/, Error, :pop!
       end
 
       state :root do
@@ -106,17 +106,17 @@ module Rouge
         rule %r((?<=\n)(?=\s|/)), Text, :expr_start
         rule %r([-<>+*/%\^!=]=?|in\b|\+\+|--|\|), Operator, :expr_start
         rule %r(&&|\|\||~!?), Operator, :expr_start
-        rule /[(\[,]/, Punctuation, :expr_start
-        rule /;/, Punctuation, :statement
-        rule /[)\].]/, Punctuation
+        rule %r/[(\[,]/, Punctuation, :expr_start
+        rule %r/;/, Punctuation, :statement
+        rule %r/[)\].]/, Punctuation
 
-        rule /[?]/ do
+        rule %r/[?]/ do
           token Punctuation
           push :ternary
           push :expr_start
         end
 
-        rule /[{}]/, Punctuation, :statement
+        rule %r/[{}]/, Punctuation, :statement
 
         rule id do |m|
           if self.class.keywords.include? m[0]
@@ -138,19 +138,19 @@ module Rouge
           end
         end
 
-        rule /[0-9]+\.[0-9]+/, Num::Float
-        rule /[0-9]+/, Num::Integer
-        rule /"(\\[\\"]|[^"])*"/, Str::Double
-        rule /:/, Punctuation
+        rule %r/[0-9]+\.[0-9]+/, Num::Float
+        rule %r/[0-9]+/, Num::Integer
+        rule %r/"(\\[\\"]|[^"])*"/, Str::Double
+        rule %r/:/, Punctuation
       end
 
       state :statement do
-        rule /[{}]/, Punctuation
+        rule %r/[{}]/, Punctuation
         mixin :expr_start
       end
 
       state :ternary do
-        rule /:/ do
+        rule %r/:/ do
           token Punctuation
           goto :expr_start
         end