rouge_ecl 0.0.1 → 1.0.0

data/lib/rouge/lexers/erb.rb

@@ -11,6 +11,10 @@ module Rouge
 
       filenames '*.erb', '*.erubis', '*.rhtml', '*.eruby'
 
+      def self.analyze_text(text)
+        return 0.4 if text =~ /<%.*%>/
+      end
+
       def initialize(opts={})
         @ruby_lexer = Ruby.new(opts)
 

data/lib/rouge/lexers/erlang.rb

@@ -11,6 +11,10 @@ module Rouge
 
       mimetypes 'text/x-erlang', 'application/x-erlang'
 
+      def self.analyze_text(text)
+        return 0.3 if text =~ /^-module[(]\w+[)][.]/
+      end
+
       keywords = %w(
         after begin case catch cond end fun if
         let of query receive try when

data/lib/rouge/lexers/factor.rb

@@ -9,8 +9,8 @@ module Rouge
       filenames '*.factor'
       mimetypes 'text/x-factor'
 
-      def self.detect?(text)
-        return true if text.shebang? 'factor'
+      def self.analyze_text(text)
+        return 1 if text.shebang? 'factor'
       end
 
       def self.builtins

data/lib/rouge/lexers/fsharp.rb

@@ -41,7 +41,7 @@ module Rouge
       end
 
       operator = %r([\[\];,{}_()!$%&*+./:<=>?@^|~#-]+)
-      id = /([a-z][\w']*)|(``[^`\n\r\t]+``)/i
+      id = /[a-z][\w']*/i
       upper_id = /[A-Z][\w']*/
 
       state :root do

data/lib/rouge/lexers/gherkin.rb

@@ -12,8 +12,8 @@ module Rouge
       filenames '*.feature'
       mimetypes 'text/x-gherkin'
 
-      def self.detect?(text)
-        return true if text.shebang? 'cucumber'
+      def self.analyze_text(text)
+        return 1 if text.shebang? 'cucumber'
       end
 
       # self-modifying method that loads the keywords file

data/lib/rouge/lexers/go.rb

@@ -11,6 +11,10 @@ module Rouge
 
       mimetypes 'text/x-go', 'application/x-go'
 
+      def self.analyze_text(text)
+        return 0
+      end
+
       # Characters
 
       WHITE_SPACE            = /[\s\t\r\n]+/

data/lib/rouge/lexers/groovy.rb

@@ -11,8 +11,8 @@ module Rouge
 
       ws = %r((?:\s|//.*?\n|/[*].*?[*]/)+)
 
-      def self.detect?(text)
-        return true if text.shebang?(/groovy/)
+      def self.analyze_text(text)
+        return 1 if text.shebang?(/groovy/)
       end
 
       def self.keywords

data/lib/rouge/lexers/haml.rb

@@ -16,6 +16,10 @@ module Rouge
       filenames '*.haml'
       mimetypes 'text/x-haml'
 
+      def self.analyze_text(text)
+        return 0.1 if text.start_with? '!!!'
+      end
+
       option 'filters[filter_name]', 'Mapping of lexers to use for haml :filters'
       attr_reader :filters
       # @option opts :filters

data/lib/rouge/lexers/haskell.rb

@@ -11,8 +11,8 @@ module Rouge
       filenames '*.hs'
       mimetypes 'text/x-haskell'
 
-      def self.detect?(text)
-        return true if text.shebang?('runhaskell')
+      def self.analyze_text(text)
+        return 1 if text.shebang?('runhaskell')
       end
 
       reserved = %w(
@@ -55,6 +55,7 @@ module Rouge
 
         rule /\bimport\b/, Keyword::Reserved, :import
         rule /\bmodule\b/, Keyword::Reserved, :module
+        rule /\berror\b/, Name::Exception
         rule /\b(?:#{reserved.join('|')})\b/, Keyword::Reserved
         # not sure why, but ^ doesn't work here
         # rule /^[_a-z][\w']*/, Name::Function
@@ -147,7 +148,7 @@ module Rouge
       state :character do
         rule /\\/ do
           token Str::Escape
-          goto :character_end
+          push :character_end
           push :escape
         end
 
@@ -173,7 +174,7 @@ module Rouge
         rule /\^[\]\[A-Z@\^_]/, Str::Escape, :pop!
         rule /#{ascii.join('|')}/, Str::Escape, :pop!
         rule /o[0-7]+/i, Str::Escape, :pop!
-        rule /x[\da-f]+/i, Str::Escape, :pop!
+        rule /x[\da-f]/i, Str::Escape, :pop!
         rule /\d+/, Str::Escape, :pop!
         rule /\s+\\/, Str::Escape, :pop!
       end

data/lib/rouge/lexers/html.rb

@@ -9,9 +9,9 @@ module Rouge
       filenames '*.htm', '*.html', '*.xhtml'
       mimetypes 'text/html', 'application/xhtml+xml'
 
-      def self.detect?(text)
-        return true if text.doctype?(/\bhtml\b/i)
-        return true if text =~ /<\s*html\b/
+      def self.analyze_text(text)
+        return 1 if text.doctype?(/\bhtml\b/i)
+        return 1 if text =~ /<\s*html\b/
       end
 
       start do
@@ -37,7 +37,6 @@ module Rouge
         rule /<\s*style\s*/m do
           token Name::Tag
           @css.reset!
-          @lang = @css
           push :style_content
           push :tag
         end
@@ -125,13 +124,13 @@ module Rouge
 
       state :style_content do
         rule /[^<]+/ do
-          delegate @lang
+          delegate @css
         end
 
         rule %r(<\s*/\s*style\s*>)m, Name::Tag, :pop!
 
         rule /</ do
-          delegate @lang
+          delegate @css
         end
       end
     end

data/lib/rouge/lexers/idlang.rb

@@ -10,6 +10,12 @@ module Rouge
       tag 'idlang'
       filenames '*.idl'
 
+      def self.analyze_text(text)
+        # Does there exist a statement that starts with 'pro' or
+        # 'function'?
+        return 0.4 if text =~ /^\s+(pro|function)\z/
+      end
+
       name = /[_A-Z]\w*/i
       kind_param = /(\d+|#{name})/
       exponent = /[dDeE][+-]\d+/

data/lib/rouge/lexers/ini.rb

@@ -11,6 +11,10 @@ module Rouge
       filenames '*.ini', '*.INI', '*.gitconfig'
       mimetypes 'text/x-ini'
 
+      def self.analyze_text(text)
+        return 0.1 if text =~ /\A\[[\w\-.]+\]\s*[\w\-]+=\w+/
+      end
+
       identifier = /[\w\-.]+/
 
       state :basic do

data/lib/rouge/lexers/io.rb

@@ -9,8 +9,8 @@ module Rouge
       mimetypes 'text/x-iosrc'
       filenames '*.io'
 
-      def self.detect?(text)
-        return true if text.shebang? 'io'
+      def self.analyze_text(text)
+        return 1 if text.shebang? 'io'
       end
 
       def self.constants

data/lib/rouge/lexers/javascript.rb

@@ -14,11 +14,11 @@ module Rouge
 
       tag 'javascript'
       aliases 'js'
-      filenames '*.js', '*.mjs'
+      filenames '*.js'
       mimetypes 'application/javascript', 'application/x-javascript',
                 'text/javascript', 'text/x-javascript'
 
-      def self.detect?(text)
+      def self.analyze_text(text)
         return 1 if text.shebang?('node')
         return 1 if text.shebang?('jsc')
         # TODO: rhino, spidermonkey, etc

data/lib/rouge/lexers/julia.rb

@@ -10,8 +10,8 @@ module Rouge
       filenames '*.jl'
       mimetypes 'text/x-julia', 'application/x-julia'
 
-      def self.detect?(text)
-        return true if text.shebang? 'julia'
+      def self.analyze_text(text)
+        1 if text.shebang? 'julia'
       end
 
       BUILTINS            = /\b(?:

data/lib/rouge/lexers/kotlin.rb

@@ -3,10 +3,8 @@
 module Rouge
   module Lexers
     class Kotlin < RegexLexer
-      # https://kotlinlang.org/docs/reference/grammar.html
-
       title "Kotlin"
-      desc "Kotlin Programming Language (http://kotlinlang.org)"
+      desc "Kotlin <http://kotlinlang.org>"
 
       tag 'kotlin'
       filenames '*.kt'
@@ -31,7 +29,7 @@ module Rouge
         rule %r'^\s*\[.*?\]', Name::Attribute
         rule %r'[^\S\n]+', Text
         rule %r'\\\n', Text # line continuation
-        rule %r'//.*?$', Comment::Single
+        rule %r'//.*?\n', Comment::Single
         rule %r'/[*].*?[*]/'m, Comment::Multiline
         rule %r'\n', Text
         rule %r'::|!!|\?[:.]', Operator
@@ -43,23 +41,26 @@ module Rouge
         rule %r'"(\\\\|\\"|[^"\n])*["\n]'m, Str
         rule %r"'\\.'|'[^\\]'", Str::Char
         rule %r"[0-9](\.[0-9]+)?([eE][+-][0-9]+)?[flFL]?|0[xX][0-9a-fA-F]+[Ll]?", Num
-        rule %r'\b(companion)(\s+)(object)\b' do
+        rule %r'(companion)(\s+)(object)' do
           groups Keyword, Text, Keyword
         end
-        rule %r'\b(class|data\s+class|interface|object)(\s+)' do
+        rule %r'(class|data\s+class|interface|object)(\s+)' do
           groups Keyword::Declaration, Text
           push :class
         end
-        rule %r'\b(package|import)(\s+)' do
+        rule %r'(package|import)(\s+)' do
           groups Keyword, Text
           push :package
         end
-        rule %r'\b(val|var)(\s+)' do
+        rule %r'(val|var)(\s+)' do
           groups Keyword::Declaration, Text
           push :property
         end
-        rule %r/\bfun\b/, Keyword
-        rule /\b(?:#{keywords.join('|')})\b/, Keyword
+        rule %r'(fun)(\s+)' do
+          groups Keyword, Text
+          push :function
+        end
+        rule /(?:#{keywords.join('|')})\b/, Keyword
         rule id, Name
       end
 
@@ -74,6 +75,10 @@ module Rouge
       state :property do
         rule id, Name::Property, :pop!
       end
+
+      state :function do
+        rule id, Name::Function, :pop!
+      end
     end
   end
 end

data/lib/rouge/lexers/lasso.rb

@@ -14,9 +14,12 @@ module Rouge
 
       option :start_inline, 'Whether to start inline instead of requiring <?lasso or ['
 
-      def self.detect?(text)
-        return true if text.shebang?('lasso9')
-        return true if text =~ /\A.*?<\?(lasso(script)?|=)/
+      def self.analyze_text(text)
+        rv = 0.0
+        rv += 1 if text.shebang?('lasso9')
+        rv += 0.4 if text =~ /<\?(lasso(script)?|=)|no_square_brackets|noprocess/i
+        rv += 0.2 if text =~ /define(_tag|_type|\s)/i
+        return rv
       end
 
       def initialize(*)

data/lib/rouge/lexers/llvm.rb

@@ -10,6 +10,10 @@ module Rouge
       filenames '*.ll'
       mimetypes 'text/x-llvm'
 
+      def self.analyze_text(text)
+        return 0.1 if text =~ /\A%\w+\s=\s/
+      end
+
       string = /"[^"]*?"/
       identifier = /([-a-zA-Z$._][-a-zA-Z$._0-9]*|#{string})/
 

data/lib/rouge/lexers/lua.rb

@@ -19,8 +19,8 @@ module Rouge
         super(opts)
       end
 
-      def self.detect?(text)
-        return true if text.shebang? 'lua'
+      def self.analyze_text(text)
+        return 1 if text.shebang? 'lua'
       end
 
       def self.builtins

data/lib/rouge/lexers/make.rb

@@ -10,6 +10,10 @@ module Rouge
       filenames '*.make', 'Makefile', 'makefile', 'Makefile.*', 'GNUmakefile'
       mimetypes 'text/x-makefile'
 
+      def self.analyze_text(text)
+        return 0.6 if text =~ /^\.PHONY:/
+      end
+
       bsd_special = %w(
         include undef error warning if else elif endif for endfor
       )

data/lib/rouge/lexers/matlab.rb

@@ -10,6 +10,10 @@ module Rouge
       filenames '*.m'
       mimetypes 'text/x-matlab', 'application/x-matlab'
 
+      def self.analyze_text(text)
+        return 0.4 if text =~ /^\s*% / # % comments are a dead giveaway
+      end
+
       def self.keywords
         @keywords = Set.new %w(
           break case catch classdef continue else elseif end for function

data/lib/rouge/lexers/moonscript.rb

@@ -22,8 +22,8 @@ module Rouge
         @disabled_modules = list_option(:disabled_modules)
       end
 
-      def self.detect?(text)
-        return true if text.shebang? 'moon'
+      def self.analyze_text(text)
+        return 1 if text.shebang? 'moon'
       end
 
       def builtins

data/lib/rouge/lexers/mosel.rb

@@ -11,9 +11,9 @@ module Rouge
       filenames '*.mos'
 
       mimetypes 'text/x-mosel'
-
-      def self.detect?(text)
-        return true if text =~ /^\s*(model|package)\s+/
+      
+      def self.analyze_text(text)
+        return 1 if text =~ /^\s*(model|package)\s+/
       end
 
       id = /[a-zA-Z_][a-zA-Z0-9_]*/

data/lib/rouge/lexers/nasm.rb

@@ -106,6 +106,11 @@ module Rouge
         )
       end
 
+      # high priority for filename matches
+      def self.analyze_text(*)
+        0.3
+      end
+
       def self.builtins
         @builtins ||= []
       end

data/lib/rouge/lexers/objective_c.rb

@@ -29,6 +29,20 @@ module Rouge
         @builtins ||= %w(YES NO nil)
       end
 
+      def self.analyze_text(text)
+        return 1 if text =~ /@(end|implementation|protocol|property)\b/
+
+        id = /[a-z$_][a-z0-9$_]*/i
+        return 0.4 if text =~ %r(
+          \[ \s* #{id} \s+
+          (?:
+            #{id} \s* \]
+            | #{id}? :
+          )
+        )x
+        return 0.4 if text.include? '@"'
+      end
+
       id = /[a-z$_][a-z0-9$_]*/i
 
       prepend :statements do

data/lib/rouge/lexers/perl.rb

@@ -12,8 +12,9 @@ module Rouge
       filenames '*.pl', '*.pm'
       mimetypes 'text/x-perl', 'application/x-perl'
 
-      def self.detect?(text)
-        return true if text.shebang? 'perl'
+      def self.analyze_text(text)
+        return 1 if text.shebang? 'perl'
+        return 0.4 if text.include? 'my $'
       end
 
       keywords = %w(
@@ -104,7 +105,6 @@ module Rouge
         rule /__END__\b/, Comment::Preproc, :end_part
         rule /\$\^[ADEFHILMOPSTWX]/, Name::Variable::Global
         rule /\$[\\"'\[\]&`+*.,;=%~?@$!<>(^\|\/-](?!\w)/, Name::Variable::Global
-        rule /[-+\/*%=<>&^\|!\\~]=?/, Operator
         rule /[$@%#]+/, Name::Variable, :varname
 
         rule /0_?[0-7]+(_[0-7]+)*/, Num::Oct
@@ -129,6 +129,7 @@ module Rouge
         rule /sub\s+/, Keyword, :funcname
         rule /\[\]|\*\*|::|<<|>>|>=|<=|<=>|={3}|!=|=~|!~|&&?|\|\||\.{1,3}/,
           Operator
+        rule /[-+\/*%=<>&^\|!\\~]=?/, Operator
         rule /[()\[\]:;,<>\/?{}]/, Punctuation
         rule(/(?=\w)/) { push :name }
       end