rouge 3.1.0 → 3.18.0

data/lib/rouge/lexers/hql.rb

@@ -0,0 +1,139 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    load_lexer 'sql.rb'
+
+    class HQL < SQL
+      title "HQL"
+      desc "Hive Query Language SQL dialect"
+      tag 'hql'
+      filenames '*.hql'
+
+      def self.keywords
+        # sources:
+        # https://cwiki.apache.org/confluence/display/Hive/LanguageManual+DDL
+        # https://cwiki.apache.org/confluence/display/Hive/LanguageManual+UDF
+        @keywords ||= Set.new(%w(
+          ADD ADMIN AFTER ANALYZE ARCHIVE ASC BEFORE BUCKET BUCKETS CASCADE
+          CHANGE CLUSTER CLUSTERED CLUSTERSTATUS COLLECTION COLUMNS COMMENT
+          COMPACT COMPACTIONS COMPUTE CONCATENATE CONTINUE DATA DATABASES
+          DATETIME DAY DBPROPERTIES DEFERRED DEFINED DELIMITED DEPENDENCY DESC
+          DIRECTORIES DIRECTORY DISABLE DISTRIBUTE ELEM_TYPE ENABLE ESCAPED
+          EXCLUSIVE EXPLAIN EXPORT FIELDS FILE FILEFORMAT FIRST FORMAT FORMATTED
+          FUNCTIONS HOLD_DDLTIME HOUR IDXPROPERTIES IGNORE INDEX INDEXES INPATH
+          INPUTDRIVER INPUTFORMAT ITEMS JAR KEYS KEY_TYPE LIMIT LINES LOAD
+          LOCATION LOCK LOCKS LOGICAL LONG MAPJOIN MATERIALIZED METADATA MINUS
+          MINUTE MONTH MSCK NOSCAN NO_DROP OFFLINE OPTION OUTPUTDRIVER
+          OUTPUTFORMAT OVERWRITE OWNER PARTITIONED PARTITIONS PLUS PRETTY
+          PRINCIPALS PROTECTION PURGE READ READONLY REBUILD RECORDREADER
+          RECORDWRITER REGEXP RELOAD RENAME REPAIR REPLACE REPLICATION RESTRICT
+          REWRITE RLIKE ROLE ROLES SCHEMA SCHEMAS SECOND SEMI SERDE
+          SERDEPROPERTIES SERVER SETS SHARED SHOW SHOW_DATABASE SKEWED SORT
+          SORTED SSL STATISTICS STORED STREAMTABLE STRING STRUCT TABLES
+          TBLPROPERTIES TEMPORARY TERMINATED TINYINT TOUCH TRANSACTIONS UNARCHIVE
+          UNDO UNIONTYPE UNLOCK UNSET UNSIGNED URI USE UTC UTCTIMESTAMP
+          VALUE_TYPE VIEW WHILE YEAR IF
+
+          ALL ALTER AND ARRAY AS AUTHORIZATION BETWEEN BIGINT BINARY BOOLEAN
+          BOTH BY CASE CAST CHAR COLUMN CONF CREATE CROSS CUBE CURRENT
+          CURRENT_DATE CURRENT_TIMESTAMP CURSOR DATABASE DATE DECIMAL DELETE
+          DESCRIBE DISTINCT DOUBLE DROP ELSE END EXCHANGE EXISTS EXTENDED
+          EXTERNAL FALSE FETCH FLOAT FOLLOWING FOR FROM FULL FUNCTION GRANT
+          GROUP GROUPING HAVING IF IMPORT IN INNER INSERT INT INTERSECT
+          INTERVAL INTO IS JOIN LATERAL LEFT LESS LIKE LOCAL MACRO MAP MORE
+          NONE NOT NULL OF ON OR ORDER OUT OUTER OVER PARTIALSCAN PARTITION
+          PERCENT PRECEDING PRESERVE PROCEDURE RANGE READS REDUCE REVOKE RIGHT
+          ROLLUP ROW ROWS SELECT SET SMALLINT TABLE TABLESAMPLE THEN TIMESTAMP
+          TO TRANSFORM TRIGGER TRUE TRUNCATE UNBOUNDED UNION UNIQUEJOIN UPDATE
+          USER USING UTC_TMESTAMP VALUES VARCHAR WHEN WHERE WINDOW WITH
+
+          AUTOCOMMIT ISOLATION LEVEL OFFSET SNAPSHOT TRANSACTION WORK WRITE
+
+          COMMIT ONLY REGEXP RLIKE ROLLBACK START
+
+          ABORT KEY LAST NORELY NOVALIDATE NULLS RELY VALIDATE
+
+          CACHE CONSTRAINT FOREIGN PRIMARY REFERENCES
+
+          DETAIL DOW EXPRESSION OPERATOR QUARTER SUMMARY VECTORIZATION WEEK YEARS MONTHS WEEKS DAYS HOURS MINUTES SECONDS
+
+          DAYOFWEEK EXTRACT FLOOR INTEGER PRECISION VIEWS
+
+          TIMESTAMPTZ ZONE
+
+          TIME NUMERIC
+
+          NAMED_STRUCT CREATE_UNION
+
+          ROUND BROUND FLOOR CEIL CEILING RAND EXP LN LOG10 LOG2 LOG POW POWER SQRT BIN
+          HEX UNHEX CONV ABS PMOD SIN ASIN COS ACOS TAN ATAN DEGREES RADIANS POSITIVE
+          NEGATIVE SIGN E PI FACTORIAL CBRT SHIFTLEFT SHIFTRIGHT SHIFTRIGHTUNSIGNED
+          GREATEST LEAST WIDTH_BUCKET SIZE SIZE MAP_KEYS MAP_VALUES ARRAY_CONTAINS
+          SORT_ARRAY BINARY CAST FROM_UNIXTIME UNIX_TIMESTAMP UNIX_TIMESTAMP
+          UNIX_TIMESTAMP TO_DATE YEAR QUARTER MONTH DAY DAYOFMONTH HOUR MINUTE SECOND
+          WEEKOFYEAR EXTRACT DATEDIFF DATE_ADD DATE_SUB FROM_UTC_TIMESTAMP
+          TO_UTC_TIMESTAMP CURRENT_DATE CURRENT_TIMESTAMP ADD_MONTHS LAST_DAY NEXT_DAY
+          TRUNC MONTHS_BETWEEN DATE_FORMAT IF ISNULL ISNOTNULL  NVL COALESCE CASE WHEN
+          then else end NULLIF ASSERT_TRUE ASCII BASE64 CHARACTER_LENGTH CHR CONCAT
+          CONTEXT_NGRAMS CONCAT_WS CONCAT_WS DECODE ELT ENCODE FIELD  FIND_IN_SET
+          FORMAT_NUMBER GET_JSON_OBJECT IN_FILE INSTR LENGTH LOCATE LOWER LCASE LPAD LTRIM
+          NGRAMS OCTET_LENGTH PARSE_URL PRINTF REGEXP_EXTRACT REGEXP_REPLACE REPEAT
+          REPLACE REVERSE RPAD RTRIM SENTENCES SPACE SPLIT STR_TO_MAP SUBSTR SUBSTRING
+          SUBSTRING_INDEX TRANSLATE TRIM UNBASE64 UPPER UCASE INITCAP LEVENSHTEIN SOUNDEX
+          MASK MASK_FIRST_N MASK_LAST_N MASK_SHOW_FIRST_N MASK_SHOW_LAST_N MASK_HASH
+          JAVA_METHOD REFLECT HASH CURRENT_USER LOGGED_IN_USER CURRENT_DATABASE MD5 SHA1
+          SHA CRC32 SHA2 AES_ENCRYPT AES_DECRYPT VERSION COUNT SUM AVG MIN MAX VARIANCE
+          VAR_POP VAR_SAMP STDDEV_POP STDDEV_SAMP COVAR_POP COVAR_SAMP CORR PERCENTILE
+          PERCENTILE_APPROX PERCENTILE_APPROX REGR_AVGX REGR_AVGY REGR_COUNT
+          REGR_INTERCEPT REGR_R2 REGR_SLOPE REGR_SXX REGR_SXY REGR_SYY HISTOGRAM_NUMERIC
+          COLLECT_SET COLLECT_LIST NTILE EXPLODE EXPLODE POSEXPLODE INLINE STACK
+
+          JSON_TUPLE PARSE_URL_TUPLE
+
+          XPATH XPATH_SHORT XPATH_INT XPATH_LONG XPATH_FLOAT XPATH_DOUBLE
+          XPATH_NUMBER XPATH_STRING GET_JSON_OBJECT JSON_TUPLE
+
+          PARSE_URL_TUPLE
+        ))
+      end
+
+      def self.keywords_type
+        # source: https://cwiki.apache.org/confluence/display/Hive/LanguageManual+Types
+        @keywords_type ||= Set.new(%w(
+            TINYINT SMALLINT INT INTEGER BIGINT FLOAT DOUBLE PRECISION DECIMAL NUMERIC
+            TIMESTAMP DATE INTERVAL
+            STRING VARCHAR CHAR
+            BOOLEAN BINARY
+            ARRAY MAP STRUCT UNIONTYPE
+        ))
+      end
+
+      prepend :root do
+        # a double-quoted string is a string literal in Hive QL.
+        rule %r/"/, Str::Double, :double_string
+
+        # interpolation of variables through ${...}
+        rule %r/\$\{/, Name::Variable, :hive_variable
+      end
+
+      prepend :single_string do
+        rule %r/\$\{/, Name::Variable, :hive_variable
+        rule %r/[^\\'\$]+/, Str::Single
+      end
+
+      prepend :double_string do
+        rule %r/\$\{/, Name::Variable, :hive_variable
+        # double-quoted strings are string literals so need to change token
+        rule %r/"/, Str::Double, :pop!
+        rule %r/[^\\"\$]+/, Str::Double
+      end
+
+      state :hive_variable do
+        rule %r/\}/, Name::Variable, :pop!
+        rule %r/[^\}]+/, Name::Variable
+      end
+
+    end
+  end
+end

data/lib/rouge/lexers/html.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers
@@ -11,6 +12,7 @@ module Rouge
 
       def self.detect?(text)
         return true if text.doctype?(/\bhtml\b/i)
+        return false if text =~ /\A<\?xml\b/
         return true if text =~ /<\s*html\b/
       end
 
@@ -20,29 +22,30 @@ module Rouge
       end
 
       state :root do
-        rule /[^<&]+/m, Text
-        rule /&\S*?;/, Name::Entity
-        rule /<!DOCTYPE .*?>/im, Comment::Preproc
-        rule /<!\[CDATA\[.*?\]\]>/m, Comment::Preproc
-        rule /<!--/, Comment, :comment
-        rule /<\?.*?\?>/m, Comment::Preproc # php? really?
-
-        rule /<\s*script\s*/m do
+        rule %r/[^<&]+/m, Text
+        rule %r/&\S*?;/, Name::Entity
+        rule %r/<!DOCTYPE .*?>/im, Comment::Preproc
+        rule %r/<!\[CDATA\[.*?\]\]>/m, Comment::Preproc
+        rule %r/<!--/, Comment, :comment
+        rule %r/<\?.*?\?>/m, Comment::Preproc # php? really?
+
+        rule %r/<\s*script\s*/m do
           token Name::Tag
           @javascript.reset!
           push :script_content
           push :tag
         end
 
-        rule /<\s*style\s*/m do
+        rule %r/<\s*style\s*/m do
           token Name::Tag
           @css.reset!
+          @lang = @css
           push :style_content
           push :tag
         end
 
-        rule /<\//, Name::Tag, :tag_end
-        rule /</, Name::Tag, :tag_start
+        rule %r(</), Name::Tag, :tag_end
+        rule %r/</, Name::Tag, :tag_start
 
         rule %r(<\s*[a-zA-Z0-9:-]+), Name::Tag, :tag # opening tags
         rule %r(<\s*/\s*[a-zA-Z0-9:-]+\s*>), Name::Tag # closing tags
@@ -50,21 +53,21 @@ module Rouge
 
       state :tag_end do
         mixin :tag_end_end
-        rule /[a-zA-Z0-9:-]+/ do
+        rule %r/[a-zA-Z0-9:-]+/ do
           token Name::Tag
           goto :tag_end_end
         end
       end
 
       state :tag_end_end do
-        rule /\s+/, Text
-        rule />/, Name::Tag, :pop!
+        rule %r/\s+/, Text
+        rule %r/>/, Name::Tag, :pop!
       end
 
       state :tag_start do
-        rule /\s+/, Text
+        rule %r/\s+/, Text
 
-        rule /[a-zA-Z0-9:-]+/ do
+        rule %r/[a-zA-Z0-9:-]+/ do
           token Name::Tag
           goto :tag
         end
@@ -73,41 +76,41 @@ module Rouge
       end
 
       state :comment do
-        rule /[^-]+/, Comment
-        rule /-->/, Comment, :pop!
-        rule /-/, Comment
+        rule %r/[^-]+/, Comment
+        rule %r/-->/, Comment, :pop!
+        rule %r/-/, Comment
       end
 
       state :tag do
-        rule /\s+/m, Text
-        rule /[a-zA-Z0-9_:-]+\s*=/m, Name::Attribute, :attr
-        rule /[a-zA-Z0-9_:-]+/, Name::Attribute
+        rule %r/\s+/m, Text
+        rule %r/[a-zA-Z0-9_:\[\]()*.-]+\s*=\s*/m, Name::Attribute, :attr
+        rule %r/[a-zA-Z0-9_:#*-]+/, Name::Attribute
         rule %r(/?\s*>)m, Name::Tag, :pop!
       end
 
       state :attr do
         # TODO: are backslash escapes valid here?
-        rule /"/ do
+        rule %r/"/ do
           token Str
           goto :dq
         end
 
-        rule /'/ do
+        rule %r/'/ do
           token Str
           goto :sq
         end
 
-        rule /[^\s>]+/, Str, :pop!
+        rule %r/[^\s>]+/, Str, :pop!
       end
 
       state :dq do
-        rule /"/, Str, :pop!
-        rule /[^"]+/, Str
+        rule %r/"/, Str, :pop!
+        rule %r/[^"]+/, Str
       end
 
       state :sq do
-        rule /'/, Str, :pop!
-        rule /[^']+/, Str
+        rule %r/'/, Str, :pop!
+        rule %r/[^']+/, Str
       end
 
       state :script_content do
@@ -123,14 +126,14 @@ module Rouge
       end
 
       state :style_content do
-        rule /[^<]+/ do
-          delegate @css
+        rule %r/[^<]+/ do
+          delegate @lang
         end
 
         rule %r(<\s*/\s*style\s*>)m, Name::Tag, :pop!
 
-        rule /</ do
-          delegate @css
+        rule %r/</ do
+          delegate @lang
         end
       end
     end

data/lib/rouge/lexers/http.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers
@@ -25,8 +26,8 @@ module Rouge
         # request
         rule %r(
           (#{HTTP.http_methods.join('|')})([ ]+) # method
-          ([^ ]+)([ ]+)                     # path
-          (HTTPS?)(/)(1[.][01])(\r?\n|$)  # http version
+          ([^ ]+)([ ]+)                          # path
+          (HTTPS?)(/)(\d(?:\.\d)?)(\r?\n|$)      # http version
         )ox do
           groups(
             Name::Function, Text,
@@ -39,9 +40,9 @@ module Rouge
 
         # response
         rule %r(
-          (HTTPS?)(/)(1[.][01])([ ]+) # http version
-          (\d{3})([ ]+)               # status
-          ([^\r\n]+)(\r?\n|$)       # status message
+          (HTTPS?)(/)(\d(?:\.\d))([ ]+)  # http version
+          (\d{3})([ ]+)?                 # status
+          ([^\r\n]*)?(\r?\n|$)           # status message
         )x do
           groups(
             Keyword, Operator, Num, Text,
@@ -53,7 +54,7 @@ module Rouge
       end
 
       state :headers do
-        rule /([^\s:]+)( *)(:)( *)([^\r\n]+)(\r?\n|$)/ do |m|
+        rule %r/([^\s:]+)( *)(:)( *)([^\r\n]+)(\r?\n|$)/ do |m|
           key = m[1]
           value = m[5]
           if key.strip.casecmp('content-type').zero?
@@ -63,15 +64,15 @@ module Rouge
           groups Name::Attribute, Text, Punctuation, Text, Str, Text
         end
 
-        rule /([^\r\n]+)(\r?\n|$)/ do
+        rule %r/([^\r\n]+)(\r?\n|$)/ do
           groups Str, Text
         end
 
-        rule /\r?\n/, Text, :content
+        rule %r/\r?\n/, Text, :content
       end
 
       state :content do
-        rule /.+/m do |m|
+        rule %r/.+/m do
           delegate(content_lexer)
         end
       end

data/lib/rouge/lexers/hylang.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers
@@ -53,22 +54,22 @@ module Rouge
       end
 
       state :root do
-        rule /;.*?$/, Comment::Single
-        rule /\s+/m, Text::Whitespace
+        rule %r/;.*?$/, Comment::Single
+        rule %r/\s+/m, Text::Whitespace
 
-        rule /-?\d+\.\d+/, Num::Float
-        rule /-?\d+/, Num::Integer
-        rule /0x-?[0-9a-fA-F]+/, Num::Hex
+        rule %r/-?\d+\.\d+/, Num::Float
+        rule %r/-?\d+/, Num::Integer
+        rule %r/0x-?[0-9a-fA-F]+/, Num::Hex
 
-        rule /"(\\.|[^"])*"/, Str
-        rule /'#{keyword}/, Str::Symbol
-        rule /::?#{keyword}/, Name::Constant
-        rule /\\(.|[a-z]+)/i, Str::Char
+        rule %r/"(\\.|[^"])*"/, Str
+        rule %r/'#{keyword}/, Str::Symbol
+        rule %r/::?#{keyword}/, Name::Constant
+        rule %r/\\(.|[a-z]+)/i, Str::Char
 
 
-        rule /~@|[`\'#^~&@]/, Operator
+        rule %r/~@|[`\'#^~&@]/, Operator
 
-        rule /(\()(\s*)(#{identifier})/m do |m|
+        rule %r/(\()(\s*)(#{identifier})/m do |m|
           token Punctuation, m[1]
           token Text::Whitespace, m[2]
           token(name_token(m[3]) || Name::Function, m[3])
@@ -79,13 +80,13 @@ module Rouge
         end
 
         # vectors
-        rule /[\[\]]/, Punctuation
+        rule %r/[\[\]]/, Punctuation
 
         # maps
-        rule /[{}]/, Punctuation
+        rule %r/[{}]/, Punctuation
 
         # parentheses
-        rule /[()]/, Punctuation
+        rule %r/[()]/, Punctuation
       end
     end
   end

data/lib/rouge/lexers/idlang.rb

@@ -1,4 +1,6 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
 # vim: set ts=2 sw=2 et:
 
 module Rouge
@@ -207,17 +209,17 @@ module Rouge
       end
 
       state :root do
-        rule /[\s\n]+/, Text::Whitespace
+        rule %r/\s+/, Text::Whitespace
         # Normal comments
-        rule /;.*$/, Comment::Single
-        rule /\,\s*\,/, Error
-        rule /\!#{name}/, Name::Variable::Global
+        rule %r/;.*$/, Comment::Single
+        rule %r/\,\s*\,/, Error
+        rule %r/\!#{name}/, Name::Variable::Global
 
-        rule /[(),:\&\$]/, Punctuation
+        rule %r/[(),:\&\$]/, Punctuation
 
         ## Format statements are quite a strange beast.
         ## Better process them in their own state.
-        #rule /\b(FORMAT)(\s*)(\()/mi do |m|
+        #rule %r/\b(FORMAT)(\s*)(\()/mi do |m|
         #  token Keyword, m[1]
         #  token Text::Whitespace, m[2]
         #  token Punctuation, m[3]
@@ -233,25 +235,25 @@ module Rouge
           (_#{kind_param})? # kind parameter
         )xi, Num::Float
 
-        rule /\d+(B|S|U|US|LL|L|ULL|UL)?/i, Num::Integer
-        rule /"[0-7]+(B|O|U|ULL|UL|LL|L)?/i, Num::Oct
-        rule /'[0-9A-F]+'X(B|S|US|ULL|UL|U|LL|L)?/i, Num::Hex
-        rule /(#{kind_param}_)?'/, Str::Single, :string_single
-        rule /(#{kind_param}_)?"/, Str::Double, :string_double
+        rule %r/\d+(B|S|U|US|LL|L|ULL|UL)?/i, Num::Integer
+        rule %r/"[0-7]+(B|O|U|ULL|UL|LL|L)?/i, Num::Oct
+        rule %r/'[0-9A-F]+'X(B|S|US|ULL|UL|U|LL|L)?/i, Num::Hex
+        rule %r/(#{kind_param}_)?'/, Str::Single, :string_single
+        rule %r/(#{kind_param}_)?"/, Str::Double, :string_double
 
         rule %r{\#\#|\#|\&\&|\|\||/=|<=|>=|->|\@|\?|[-+*/<=~^{}]}, Operator
         # Structures and the like
-        rule /(#{name})(\.)([^\s,]*)/i do |m|
+        rule %r/(#{name})(\.)([^\s,]*)/i do
           groups Name, Operator, Name
           #delegate IDLang, m[3]
         end
 
-        rule /(function|pro)((?:\s|\$\s)+)/i do
+        rule %r/(function|pro)((?:\s|\$\s)+)/i do
           groups Keyword, Text::Whitespace
           push :funcname
         end
 
-        rule /#{name}/m do |m|
+        rule %r/#{name}/m do |m|
           match = m[0].upcase
           if self.class.keywords.include? match
             token Keyword
@@ -273,37 +275,37 @@ module Rouge
       end
 
       state :funcname do
-        rule /#{name}/, Name::Function
+        rule %r/#{name}/, Name::Function
 
-        rule /\s+/, Text::Whitespace
-        rule /(:+|\$)/, Operator
-        rule /;.*/, Comment::Single
+        rule %r/\s+/, Text::Whitespace
+        rule %r/(:+|\$)/, Operator
+        rule %r/;.*/, Comment::Single
 
         # Be done with this state if we hit EOL or comma
-        rule /$/, Text::Whitespace, :pop!
-        rule /,/, Operator, :pop!
+        rule %r/$/, Text::Whitespace, :pop!
+        rule %r/,/, Operator, :pop!
       end
 
       state :string_single do
-        rule /[^']+/, Str::Single
-        rule /''/, Str::Escape
-        rule /'/, Str::Single, :pop!
+        rule %r/[^']+/, Str::Single
+        rule %r/''/, Str::Escape
+        rule %r/'/, Str::Single, :pop!
       end
 
       state :string_double do
-        rule /[^"]+/, Str::Double
-        rule /"/, Str::Double, :pop!
+        rule %r/[^"]+/, Str::Double
+        rule %r/"/, 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
+        rule %r/'/, Str::Single, :string_single
+        rule %r/"/, Str::Double, :string_double
+        rule %r/\(/, Punctuation, :format_spec
+        rule %r/\)/, Punctuation, :pop!
+        rule %r/,/, Punctuation
+        rule %r/\s+/, Text::Whitespace
         # Edit descriptors could be seen as a kind of "format literal".
-        rule /[^\s'"(),]+/, Literal
+        rule %r/[^\s'"(),]+/, Literal
       end
     end
   end