rouge 1.10.1 → 1.11.0

data/lib/rouge/lexers/diff.rb

@@ -16,15 +16,15 @@ module Rouge
       end
 
       state :root do
-        rule(/^ .*\n/, Text)
-        rule(/^---\n/, Text)
-        rule(/^\+.*\n/, Generic::Inserted)
-        rule(/^-+.*\n/, Generic::Deleted)
-        rule(/^!.*\n/, Generic::Strong)
-        rule(/^@.*\n/, Generic::Subheading)
-        rule(/^([Ii]ndex|diff).*\n/, Generic::Heading)
-        rule(/^=.*\n/, Generic::Heading)
-        rule(/.*\n/, Text)
+        rule(/^ .*$\n?/, Text)
+        rule(/^---$\n?/, Text)
+        rule(/^\+.*$\n?/, Generic::Inserted)
+        rule(/^-+.*$\n?/, Generic::Deleted)
+        rule(/^!.*$\n?/, Generic::Strong)
+        rule(/^@.*$\n?/, Generic::Subheading)
+        rule(/^([Ii]ndex|diff).*$\n?/, Generic::Heading)
+        rule(/^=.*$\n?/, Generic::Heading)
+        rule(/.*$\n?/, Text)
       end
     end
   end

data/lib/rouge/lexers/eiffel.rb

@@ -0,0 +1,65 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class Eiffel < RegexLexer
+      title "Eiffel"
+      desc "Eiffel programming language"
+
+      tag 'eiffel'
+      filenames '*.e'
+      mimetypes 'text/x-eiffel'
+
+      LanguageKeywords = %w(
+        across agent alias all and attached as assign attribute check
+        class convert create debug deferred detachable do else elseif end
+        ensure expanded export external feature from frozen if implies  inherit
+        inspect invariant like local loop not note obsolete old once or
+        Precursor redefine rename require rescue retry select separate
+        some then undefine until variant Void when xor
+      )
+
+      BooleanConstants = %w(True False)
+
+      LanguageVariables = %w(Current Result)
+
+      SimpleString = /(?:[^"%\b\f\v]|%[A-DFHLNQR-V%'"()<>]|%\/(?:0[xX][\da-fA-F](?:_*[\da-fA-F])*|0[cC][0-7](?:_*[0-7])*|0[bB][01](?:_*[01])*|\d(?:_*\d)*)\/)+?/
+
+      state :root do
+        rule /"\[/, Str::Other, :aligned_verbatim_string
+        rule /"\{/, Str::Other, :non_aligned_verbatim_string
+        rule /"(?:[^%\b\f\n\r\v]|%[A-DFHLNQR-V%'"()<>]|%\/(?:0[xX][\da-fA-F](?:_*[\da-fA-F])*|0[cC][0-7](?:_*[0-7])*|0[bB][01](?:_*[01])*|\d(?:_*\d)*)\/)*?"/, Str::Double
+        rule /--.*/, Comment::Single
+        rule /'(?:[^%\b\f\n\r\t\v]|%[A-DFHLNQR-V%'"()<>]|%\/(?:0[xX][\da-fA-F](?:_*[\da-fA-F])*|0[cC][0-7](?:_*[0-7])*|0[bB][01](?:_*[01])*|\d(?:_*\d)*)\/)'/, Str::Char
+
+        rule /(?:#{LanguageKeywords.join('|')})\b/, Keyword
+        rule /(?:#{LanguageVariables.join('|')})\b/, Keyword::Variable
+        rule /(?:#{BooleanConstants.join('|')})\b/, Keyword::Constant
+
+        rule  /\b0[xX][\da-fA-F](?:_*[\da-fA-F])*b/, Num::Hex
+        rule /\b0[cC][0-7](?:_*[0-7])*\b/, Num::Oct
+        rule /\b0[bB][01](?:_*[01])*\b/, Num::Bin
+        rule /\d(?:_*\d)*/, Num::Integer
+        rule /(?:\d(?:_*\d)*)?\.(?:(?:\d(?:_*\d)*)?[eE][+-]?)?\d(?:_*\d)*|\d(?:_*\d)*\.?/, Num::Float
+
+        rule /:=|<<|>>|\(\||\|\)|->|\.|[{}\[\];(),:?]/, Punctuation::Indicator
+        rule /\\\\|\|\.\.\||\.\.|\/[~\/]?|[><\/]=?|[-+*^=~]/, Operator
+
+        rule /[A-Z][\dA-Z_]*/, Name::Class
+        rule /[A-Za-z][\dA-Za-z_]*/, Name
+        rule /\s+/, Text
+      end
+
+      state :aligned_verbatim_string do
+        rule /]"/, Str::Other, :pop!
+        rule SimpleString, Str::Other
+      end
+
+      state :non_aligned_verbatim_string do
+        rule /}"/, Str::Other, :pop!
+        rule SimpleString, Str::Other
+      end
+    end
+  end
+end
+

data/lib/rouge/lexers/fortran.rb

@@ -0,0 +1,142 @@
+# -*- coding: utf-8 -*- #
+# vim: set ts=2 sw=2 et:
+
+# TODO: Implement format list support.
+
+module Rouge
+  module Lexers
+    class Fortran < RegexLexer
+      title "Fortran"
+      desc "Fortran 95 Programming Language"
+
+      tag 'fortran'
+      filenames '*.f90', '*.f95',
+                '*.F90', '*.F95'
+      mimetypes 'text/x-fortran'
+
+      name = /[A-Z][_A-Z0-9]*/i
+      kind_param = /(\d+|#{name})/
+      exponent = /[ED][+-]\d+/
+
+      def self.keywords
+        # Fortran allows to omit whitespace between certain keywords...
+        @keywords ||= Set.new %w(
+          allocatable allocate assignment backspace block blockdata call case
+          close common contains continue cycle data deallocate default
+          dimension do elemental else elseif elsewhere end endblockdata enddo
+          endfile endforall endfunction endif endinterface endmodule endprogram
+          endselect endsubroutine endtype endwhere entry equivalence exit
+          external forall format function go goto if implicit in include inout
+          inquire intent interface intrinsic module namelist none nullify only
+          open operator optional out parameter pointer print private procedure
+          program public pure read recursive result return rewind save select
+          selectcase sequence stop subroutine target then to type use where
+          while write
+        )
+      end
+
+      def self.types
+        @types ||= Set.new %w(
+          character complex double precision doubleprecision integer logical real
+        )
+      end
+
+      def self.intrinsics
+        @intrinsics ||= Set.new %w(
+          abs achar acos adjustl adjustr aimag aint all allocated anint any
+          asin associated atan atan2 bit_size btest ceiling char cmplx conjg
+          cos cosh count cpu_time cshift date_and_time dble digits dim
+          dot_product dprod eoshift epsilon exp exponent floor fraction huge
+          iachar iand ibclr ibits ibset ichar ieor index int ior ishift ishiftc
+          kind lbound len len_trim lge lgt lle llt log log10 logical matmul max
+          maxexponent maxloc maxval merge min minexponent minloc minval mod
+          modulo mvbits nearest nint not null pack precision present product
+          radix random_number random_seed range real repeat reshape rrspacing
+          scale scan selected_int_kind selected_real_kind set_exponent shape
+          sign sin sinh size spacing spread sqrt sum system_clock tan tanh tiny
+          transfer transpose trim ubound unpack verify
+        )
+      end
+
+      state :root do
+        rule /[\s\n]+/, Text::Whitespace
+        rule /!.*$/, Comment::Single
+        rule /^#.*$/, Comment::Preproc
+
+        rule /::|[()\/;,:&]/, Punctuation
+
+        # TODO: This does not take into account line continuation.
+        rule /^(\s*)([0-9]+)\b/m do |m|
+          token Text::Whitespace, m[1]
+          token Name::Label, m[2]
+        end
+
+        # Format statements are quite a strange beast.
+        # Better process them in their own state.
+        rule /\b(FORMAT)(\s*)(\()/mi do |m|
+          token Keyword, m[1]
+          token Text::Whitespace, m[2]
+          token Punctuation, m[3]
+          push :format_spec
+        end
+
+        rule %r(
+          [+-]? # sign
+          (
+            (\d+[.]\d*|[.]\d+)(#{exponent})?
+            | \d+#{exponent} # exponent is mandatory
+          )
+          (_#{kind_param})? # kind parameter
+        )xi, Num::Float
+
+        rule /[+-]?\d+(_#{kind_param})?/i, Num::Integer
+        rule /B'[01]+'|B"[01]+"/i, Num::Bin
+        rule /O'[0-7]+'|O"[0-7]+"/i, Num::Oct
+        rule /Z'[0-9A-F]+'|Z"[0-9A-F]+"/i, Num::Hex
+        rule /(#{kind_param}_)?'/, Str::Single, :string_single
+        rule /(#{kind_param}_)?"/, Str::Double, :string_double
+        rule /[.](TRUE|FALSE)[.](_#{kind_param})?/i, Keyword::Constant
+
+        rule %r{\*\*|//|==|/=|<=|>=|=>|[-+*/<>=%]}, Operator
+        rule /\.(?:EQ|NE|LT|LE|GT|GE|NOT|AND|OR|EQV|NEQV|[A-Z]+)\./i, Operator::Word
+
+        rule /#{name}/m do |m|
+          match = m[0].downcase
+          if self.class.keywords.include? match
+            token Keyword
+          elsif self.class.types.include? match
+            token Keyword::Type
+          elsif self.class.intrinsics.include? match
+            token Name::Builtin
+          else
+            token Name
+          end
+        end
+
+      end
+
+      state :string_single do
+        rule /[^']+/, Str::Single
+        rule /''/, Str::Escape
+        rule /'/, Str::Single, :pop!
+      end
+
+      state :string_double do
+        rule /[^"]+/, Str::Double
+        rule /""/, Str::Escape
+        rule /"/, Str::Double, :pop!
+      end
+
+      state :format_spec do
+        rule /'/, Str::Single, :string_single
+        rule /"/, Str::Double, :string_double
+        rule /\(/, Punctuation, :format_spec
+        rule /\)/, Punctuation, :pop!
+        rule /,/, Punctuation
+        rule /[\s\n]+/, Text::Whitespace
+        # Edit descriptors could be seen as a kind of "format literal".
+        rule /[^\s'"(),]+/, Literal
+      end
+    end
+  end
+end

data/lib/rouge/lexers/gradle.rb

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    load_lexer 'groovy.rb'
+
+    class Gradle < Groovy
+      title "Gradle"
+      desc "A powerful build system for the JVM"
+
+      tag 'gradle'
+      filenames '*.gradle'
+      mimetypes 'text/x-gradle'
+
+      def self.keywords
+        @keywords ||= super + Set.new(%w(
+          allprojects artifacts buildscript configuration dependencies
+          repositories sourceSets subprojects publishing
+        ))
+      end
+
+      def self.types
+        @types ||= super + Set.new(%w(
+          Project Task Gradle Settings Script JavaToolChain SourceSet
+          SourceSetOutput IncrementalTaskInputs Configuration
+          ResolutionStrategy ArtifactResolutionQuery ComponentSelection
+          ComponentSelectionRules ConventionProperty ExtensionAware
+          ExtraPropertiesExtension PublishingExtension IvyPublication
+          IvyArtifact IvyArtifactSet IvyModuleDescriptorSpec
+          MavenPublication MavenArtifact MavenArtifactSet MavenPom
+          PluginDependenciesSpec PluginDependencySpec ResourceHandler
+          TextResourceFactory
+        ))
+      end
+    end
+  end
+end

data/lib/rouge/lexers/groovy.rb

@@ -4,7 +4,7 @@ module Rouge
   module Lexers
     class Groovy < RegexLexer
       title "Groovy"
-      desc 'The Groovy programming language (groovy.codehaus.org)'
+      desc 'The Groovy programming language (http://www.groovy-lang.org/)'
       tag 'groovy'
       filenames '*.groovy'
       mimetypes 'text/x-groovy'
@@ -53,7 +53,7 @@ module Rouge
         rule %r(//.*?$), Comment::Single
         rule %r(/[*].*?[*]/)m, Comment::Multiline
         rule /@\w[\w\d.]*/, Name::Decorator
-        rule /(class|interface)\b/,  Keyword::Declaration, :class
+        rule /(class|interface|trait)\b/,  Keyword::Declaration, :class
         rule /package\b/, Keyword::Namespace, :import
         rule /import\b/, Keyword::Namespace, :import
 

data/lib/rouge/lexers/ini.rb

@@ -12,10 +12,10 @@ module Rouge
       mimetypes 'text/x-ini'
 
       def self.analyze_text(text)
-        return 0.1 if text =~ /\A\[[\w.]+\]\s*\w+=\w+/
+        return 0.1 if text =~ /\A\[[\w\-.]+\]\s*[\w\-]+=\w+/
       end
 
-      identifier = /[\w.]+/
+      identifier = /[\w\-.]+/
 
       state :basic do
         rule /[;#].*?\n/, Comment

data/lib/rouge/lexers/java.rb

@@ -25,8 +25,15 @@ module Rouge
       id = /[a-zA-Z_][a-zA-Z0-9_]*/
 
       state :root do
-        rule %r(^
-          (\s*(?:[a-zA-Z_][a-zA-Z0-9_.\[\]]*\s+)+?) # return arguments
+        rule /[^\S\n]+/, Text
+        rule %r(//.*?$), Comment::Single
+        rule %r(/\*.*?\*/)m, Comment::Multiline
+        # keywords: go before method names to avoid lexing "throw new XYZ"
+        # as a method signature
+        rule /(?:#{keywords.join('|')})\b/, Keyword
+
+        rule %r(
+          (\s*(?:[a-zA-Z_][a-zA-Z0-9_.\[\]<>]*\s+)+?) # return arguments
           ([a-zA-Z_][a-zA-Z0-9_]*)                  # method name
           (\s*)(\()                                 # signature start
         )mx do |m|
@@ -34,14 +41,10 @@ module Rouge
           delegate Java, m[1]
           token Name::Function, m[2]
           token Text, m[3]
-          token Punctuation, m[4]
+          token Operator, m[4]
         end
 
-        rule /\s+/, Text
-        rule %r(//.*?$), Comment::Single
-        rule %r(/\*.*?\*/)m, Comment::Multiline
         rule /@#{id}/, Name::Decorator
-        rule /(?:#{keywords.join('|')})\b/, Keyword
         rule /(?:#{declarations.join('|')})\b/, Keyword::Declaration
         rule /(?:#{types.join('|')})\b/, Keyword::Type
         rule /package\b/, Keyword::Namespace
@@ -59,7 +62,7 @@ module Rouge
         rule /[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?/, Num::Float
         rule /0x[0-9a-f]+/, Num::Hex
         rule /[0-9]+L?/, Num::Integer
-        # rule /\n/, Text
+        rule /\n/, Text
       end
 
       state :class do

data/lib/rouge/lexers/javascript.rb

@@ -206,7 +206,8 @@ module Rouge
       desc "JavaScript Object Notation (json.org)"
       tag 'json'
       filenames '*.json'
-      mimetypes 'application/json', 'application/vnd.api+json'
+      mimetypes 'application/json', 'application/vnd.api+json',
+                'application/hal+json'
 
       # TODO: is this too much of a performance hit?  JSON is quite simple,
       # so I'd think this wouldn't be too bad, but for large documents this

data/lib/rouge/lexers/jinja.rb

@@ -0,0 +1,137 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class Jinja < TemplateLexer
+      title "Jinja"
+      desc "Django/Jinja template engine (jinja.pocoo.org)"
+
+      tag 'jinja'
+      aliases 'django'
+
+      mimetypes 'application/x-django-templating', 'application/x-jinja',
+                'text/html+django', 'text/html+jinja'
+
+      def self.keywords
+        @@keywords ||= %w(as context do else extends from ignore missing
+                          import include reversed recursive scoped
+                          autoescape endautoescape block endblock call endcall
+                          filter endfilter for endfor if endif macro endmacro
+                          set endset trans endtrans with endwith without)
+      end
+
+      def self.tests
+        @@tests ||= %w(callable defined divisibleby equalto escaped even iterable
+                       lower mapping none number odd sameas sequence string
+                       undefined upper)
+      end
+
+      def self.pseudo_keywords
+        @@pseudo_keywords ||= %w(true false none True False None)
+      end
+
+      def self.word_operators
+        @@word_operators ||= %w(is in and or not)
+      end
+
+      state :root do
+        # Comments
+        rule /{#/, Comment, :comment
+
+        # Statements
+        rule /\{\%/ do
+          token Comment::Preproc
+          push :statement
+        end
+
+        # Expressions
+        rule /\{\{/ do
+          token Comment::Preproc
+          push :expression
+        end
+
+        rule(/(.+?)(?=\\|{{|{%|{#)/m) { delegate parent }
+        rule(/.+/m) { delegate parent }
+      end
+
+      state :filter do
+        # Filters are called like variable|foo(arg1, ...)
+        rule /(\|)(\w+)/ do
+          groups Operator, Name::Function
+        end
+      end
+
+      state :function do
+        rule /(\w+)(\()/ do
+          groups Name::Function, Punctuation
+        end
+      end
+
+      state :text do
+        rule /\s+/m, Text
+      end
+
+      state :literal do
+        # Strings
+        rule /"(\\.|.)*?"/, Str::Double
+        rule /'(\\.|.)*?'/, Str::Single
+
+        # Numbers
+        rule /\d+(?=}\s)/, Num
+
+        # Arithmetic operators (+, -, *, **, //, /)
+        # TODO : implement modulo (%)
+        rule /(\+|\-|\*|\/\/?|\*\*?)/, Operator
+
+        # Comparisons operators (<=, <, >=, >, ==, ===, !=)
+        rule /(<=?|>=?|===?|!=)/, Operator
+
+        # Punctuation (the comma, [], ())
+        rule /,/,  Punctuation
+        rule /\[/, Punctuation
+        rule /\]/, Punctuation
+        rule /\(/, Punctuation
+        rule /\)/, Punctuation
+      end
+
+      state :comment do
+        rule(/[^{#]+/m) { token Comment }
+        rule(/#}/) { token Comment; pop! }
+      end
+
+      state :expression do
+        rule /\w+\.?/m, Name::Variable
+
+        mixin :filter
+        mixin :function
+        mixin :literal
+        mixin :text
+
+        rule /%}|}}/, Comment::Preproc, :pop!
+      end
+
+      state :statement do
+        rule /(\w+\.?)/ do |m|
+          if self.class.keywords.include?(m[0])
+            groups Keyword
+          elsif self.class.pseudo_keywords.include?(m[0])
+            groups Keyword::Pseudo
+          elsif self.class.word_operators.include?(m[0])
+            groups Operator::Word
+          elsif self.class.tests.include?(m[0])
+            groups Name::Builtin
+          else
+            groups Name::Variable
+          end
+        end
+
+        mixin :filter
+        mixin :function
+        mixin :literal
+        mixin :text
+
+        rule /\%\}/, Comment::Preproc, :pop!
+      end
+    end
+  end
+end