rouge 3.0.0 → 3.18.0

data/lib/rouge/lexers/d.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers
@@ -34,75 +35,75 @@ module Rouge
       )
 
       keywords_pseudo = %w(
-        __FILE__ __MODULE__ __LINE__ __FUNCTION__ __PRETTY_FUNCTION__
-         __DATE__ __EOF__ __TIME__ __TIMESTAMP__ __VENDOR__
-        __VERSION__
+        __FILE__ __FILE_FULL_PATH__ __MODULE__ __LINE__ __FUNCTION__
+        __PRETTY_FUNCTION__ __DATE__ __EOF__ __TIME__ __TIMESTAMP__
+        __VENDOR__ __VERSION__
       )
 
       state :whitespace do
-        rule /\n/m, Text
-        rule /\s+/m, Text
+        rule %r/\n/m, Text
+        rule %r/\s+/m, Text
       end
 
       state :root do
         mixin :whitespace
         # Comments
-        rule %r(//(.*?)\n), Comment::Single
+        rule %r(//.*), Comment::Single
         rule %r(/(\\\n)?[*](.|\n)*?[*](\\\n)?/), Comment::Multiline
         rule %r(/\+), Comment::Multiline, :nested_comment
         # Keywords
-        rule /(#{keywords.join('|')})\b/, Keyword
-        rule /(#{keywords_type.join('|')})\b/, Keyword::Type
-        rule /(false|true|null)\b/, Keyword::Constant
-        rule /(#{keywords_pseudo.join('|')})\b/, Keyword::Pseudo
-        rule /macro\b/, Keyword::Reserved
-        rule /(string|wstring|dstring|size_t|ptrdiff_t)\b/, Name::Builtin
+        rule %r/(#{keywords.join('|')})\b/, Keyword
+        rule %r/(#{keywords_type.join('|')})\b/, Keyword::Type
+        rule %r/(false|true|null)\b/, Keyword::Constant
+        rule %r/(#{keywords_pseudo.join('|')})\b/, Keyword::Pseudo
+        rule %r/macro\b/, Keyword::Reserved
+        rule %r/(string|wstring|dstring|size_t|ptrdiff_t)\b/, Name::Builtin
         # Literals
         # HexFloat
-        rule /0[xX]([0-9a-fA-F_]*\.[0-9a-fA-F_]+|[0-9a-fA-F_]+)[pP][+\-]?[0-9_]+[fFL]?[i]?/, Num::Float
+        rule %r/0[xX]([0-9a-fA-F_]*\.[0-9a-fA-F_]+|[0-9a-fA-F_]+)[pP][+\-]?[0-9_]+[fFL]?[i]?/, Num::Float
         # DecimalFloat
-        rule /[0-9_]+(\.[0-9_]+[eE][+\-]?[0-9_]+|\.[0-9_]*|[eE][+\-]?[0-9_]+)[fFL]?[i]?/, Num::Float
-        rule /\.(0|[1-9][0-9_]*)([eE][+\-]?[0-9_]+)?[fFL]?[i]?/, Num::Float
+        rule %r/[0-9_]+(\.[0-9_]+[eE][+\-]?[0-9_]+|\.[0-9_]*|[eE][+\-]?[0-9_]+)[fFL]?[i]?/, Num::Float
+        rule %r/\.(0|[1-9][0-9_]*)([eE][+\-]?[0-9_]+)?[fFL]?[i]?/, Num::Float
         # IntegerLiteral
         # Binary
-        rule /0[Bb][01_]+/, Num::Bin
+        rule %r/0[Bb][01_]+/, Num::Bin
         # Octal
         # TODO: 0[0-7] isn't supported use octal![0-7] instead
-        rule /0[0-7_]+/, Num::Oct
+        rule %r/0[0-7_]+/, Num::Oct
         # Hexadecimal
-        rule /0[xX][0-9a-fA-F_]+/, Num::Hex
+        rule %r/0[xX][0-9a-fA-F_]+/, Num::Hex
         # Decimal
-        rule /(0|[1-9][0-9_]*)([LUu]|Lu|LU|uL|UL)?/, Num::Integer
+        rule %r/(0|[1-9][0-9_]*)([LUu]|Lu|LU|uL|UL)?/, Num::Integer
         # CharacterLiteral
-        rule /'(\\['"?\\abfnrtv]|\\x[0-9a-fA-F]{2}|\\[0-7]{1,3}|\\u[0-9a-fA-F]{4}|\\U[0-9a-fA-F]{8}|\\&\w+;|.)'/, Str::Char
+        rule %r/'(\\['"?\\abfnrtv]|\\x[0-9a-fA-F]{2}|\\[0-7]{1,3}|\\u[0-9a-fA-F]{4}|\\U[0-9a-fA-F]{8}|\\&\w+;|.)'/, Str::Char
         # StringLiteral
         # WysiwygString
-        rule /r"[^"]*"[cwd]?/, Str
+        rule %r/r"[^"]*"[cwd]?/, Str
         # Alternate WysiwygString
-        rule /`[^`]*`[cwd]?/, Str
+        rule %r/`[^`]*`[cwd]?/, Str
         # DoubleQuotedString
-        rule /"(\\\\|\\"|[^"])*"[cwd]?/, Str
+        rule %r/"(\\\\|\\"|[^"])*"[cwd]?/, Str
         # EscapeSequence
-        rule /\\(['\"?\\abfnrtv]|x[0-9a-fA-F]{2}|[0-7]{1,3}|u[0-9a-fA-F]{4}|U[0-9a-fA-F]{8}|&\w+;)/, Str
+        rule %r/\\(['\"?\\abfnrtv]|x[0-9a-fA-F]{2}|[0-7]{1,3}|u[0-9a-fA-F]{4}|U[0-9a-fA-F]{8}|&\w+;)/, Str
         # HexString
-        rule /x"[0-9a-fA-F_\s]*"[cwd]?/, Str
+        rule %r/x"[0-9a-fA-F_\s]*"[cwd]?/, Str
         # DelimitedString
-        rule /q"\[/, Str, :delimited_bracket
-        rule /q"\(/, Str, :delimited_parenthesis
-        rule /q"</, Str, :delimited_angle
-        rule /q"\{/, Str, :delimited_curly
-        rule /q"([a-zA-Z_]\w*)\n.*?\n\1"/, Str
-        rule /q"(.).*?\1"/, Str
+        rule %r/q"\[/, Str, :delimited_bracket
+        rule %r/q"\(/, Str, :delimited_parenthesis
+        rule %r/q"</, Str, :delimited_angle
+        rule %r/q"\{/, Str, :delimited_curly
+        rule %r/q"([a-zA-Z_]\w*)\n.*?\n\1"/, Str
+        rule %r/q"(.).*?\1"/, Str
         # TokenString
-        rule /q\{/, Str, :token_string
+        rule %r/q\{/, Str, :token_string
         # Attributes
-        rule /@([a-zA-Z_]\w*)?/, Name::Decorator
+        rule %r/@([a-zA-Z_]\w*)?/, Name::Decorator
         # Tokens
         rule %r`(~=|\^=|%=|\*=|==|!>=|!<=|!<>=|!<>|!<|!>|!=|>>>=|>>>|>>=|>>|>=|<>=|<>|<<=|<<|<=|\+\+|\+=|--|-=|\|\||\|=|&&|&=|\.\.\.|\.\.|/=)|[/.&|\-+<>!()\[\]{}?,;:$=*%^~]`, Punctuation
         # Identifier
-        rule /[a-zA-Z_]\w*/, Name
+        rule %r/[a-zA-Z_]\w*/, Name
         # Line
-        rule /#line\s.*\n/, Comment::Special
+        rule %r/#line\s.*\n/, Comment::Special
       end
 
       state :nested_comment do
@@ -113,63 +114,63 @@ module Rouge
       end
 
       state :token_string do
-        rule /\{/, Punctuation, :token_string_nest
-        rule /\}/, Str, :pop!
+        rule %r/\{/, Punctuation, :token_string_nest
+        rule %r/\}/, Str, :pop!
         mixin :root
       end
 
       state :token_string_nest do
-        rule /\{/, Punctuation, :push
-        rule /\}/, Punctuation, :pop!
+        rule %r/\{/, Punctuation, :push
+        rule %r/\}/, Punctuation, :pop!
         mixin :root
       end
 
       state :delimited_bracket do
-        rule /[^\[\]]+/, Str
-        rule /\[/, Str, :delimited_inside_bracket
-        rule /\]"/, Str, :pop!
+        rule %r/[^\[\]]+/, Str
+        rule %r/\[/, Str, :delimited_inside_bracket
+        rule %r/\]"/, Str, :pop!
       end
 
       state :delimited_inside_bracket do
-        rule /[^\[\]]+/, Str
-        rule /\[/, Str, :push
-        rule /\]/, Str, :pop!
+        rule %r/[^\[\]]+/, Str
+        rule %r/\[/, Str, :push
+        rule %r/\]/, Str, :pop!
       end
 
       state :delimited_parenthesis do
-        rule /[^()]+/, Str
-        rule /\(/, Str, :delimited_inside_parenthesis
-        rule /\)"/, Str, :pop!
+        rule %r/[^()]+/, Str
+        rule %r/\(/, Str, :delimited_inside_parenthesis
+        rule %r/\)"/, Str, :pop!
       end
 
       state :delimited_inside_parenthesis do
-        rule /[^()]+/, Str
-        rule /\(/, Str, :push
-        rule /\)/, Str, :pop!
+        rule %r/[^()]+/, Str
+        rule %r/\(/, Str, :push
+        rule %r/\)/, Str, :pop!
       end
 
       state :delimited_angle do
-        rule /[^<>]+/, Str
-        rule /</, Str, :delimited_inside_angle
-        rule />"/, Str, :pop!
+        rule %r/[^<>]+/, Str
+        rule %r/</, Str, :delimited_inside_angle
+        rule %r/>"/, Str, :pop!
       end
 
       state :delimited_inside_angle do
-        rule /[^<>]+/, Str
-        rule /</, Str, :push
-        rule />/, Str, :pop!
+        rule %r/[^<>]+/, Str
+        rule %r/</, Str, :push
+        rule %r/>/, Str, :pop!
       end
 
       state :delimited_curly do
-        rule /[^{}]+/, Str
-        rule /\{/, Str, :delimited_inside_curly
-        rule /\}"/, Str, :pop!
+        rule %r/[^{}]+/, Str
+        rule %r/\{/, Str, :delimited_inside_curly
+        rule %r/\}"/, Str, :pop!
       end
 
       state :delimited_inside_curly do
-        rule /[^{}]+/, Str
-        rule /\{/, Str, :push
-        rule /\}/, Str, :pop!
+        rule %r/[^{}]+/, Str
+        rule %r/\{/, Str, :push
+        rule %r/\}/, Str, :pop!
       end
     end
   end

data/lib/rouge/lexers/dart.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers
@@ -29,8 +30,8 @@ module Rouge
       state :root do
         rule %r(^
           (\s*(?:[a-zA-Z_][a-zA-Z\d_.\[\]]*\s+)+?) # return arguments
-          ([a-zA-Z_][\w]*)                          # method name
-          (\s*)(\()                                 # signature start
+          ([a-zA-Z_]\w*)                           # method name
+          (\s*)(\()                                # signature start
         )mx do |m|
           # TODO: do this better, this shouldn't need a delegation
           delegate Dart, m[1]
@@ -39,65 +40,65 @@ module Rouge
           token Punctuation, m[4]
         end
 
-        rule /\s+/, Text
+        rule %r/\s+/, Text
         rule %r(//.*?$), Comment::Single
         rule %r(/\*.*?\*/)m, Comment::Multiline
-        rule /"/, Str, :dqs
-        rule /'/, Str, :sqs
-        rule /r"[^"]*"/, Str::Other
-        rule /r'[^']*'/, Str::Other
-        rule /##{id}*/i, Str::Symbol
-        rule /@#{id}/, Name::Decorator
-        rule /(?:#{keywords.join('|')})\b/, Keyword
-        rule /(?:#{declarations.join('|')})\b/, Keyword::Declaration
-        rule /(?:#{types.join('|')})\b/, Keyword::Type
-        rule /(?:true|false|null)\b/, Keyword::Constant
-        rule /(?:class|interface)\b/, Keyword::Declaration, :class
-        rule /(?:#{imports.join('|')})\b/, Keyword::Namespace, :import
-        rule /(\.)(#{id})/ do
+        rule %r/"/, Str, :dqs
+        rule %r/'/, Str, :sqs
+        rule %r/r"[^"]*"/, Str::Other
+        rule %r/r'[^']*'/, Str::Other
+        rule %r/##{id}*/i, Str::Symbol
+        rule %r/@#{id}/, Name::Decorator
+        rule %r/(?:#{keywords.join('|')})\b/, Keyword
+        rule %r/(?:#{declarations.join('|')})\b/, Keyword::Declaration
+        rule %r/(?:#{types.join('|')})\b/, Keyword::Type
+        rule %r/(?:true|false|null)\b/, Keyword::Constant
+        rule %r/(?:class|interface)\b/, Keyword::Declaration, :class
+        rule %r/(?:#{imports.join('|')})\b/, Keyword::Namespace, :import
+        rule %r/(\.)(#{id})/ do
           groups Operator, Name::Attribute
         end
 
-        rule /#{id}:/, Name::Label
-        rule /\$?#{id}/, Name
-        rule /[~^*!%&\[\](){}<>\|+=:;,.\/?-]/, Operator
-        rule /\d*\.\d+([eE]\-?\d+)?/, Num::Float
-        rule /0x[\da-fA-F]+/, Num::Hex
-        rule /\d+L?/, Num::Integer
-        rule /\n/, Text
+        rule %r/#{id}:/, Name::Label
+        rule %r/\$?#{id}/, Name
+        rule %r/[~^*!%&\[\](){}<>\|+=:;,.\/?-]/, Operator
+        rule %r/\d*\.\d+([eE]\-?\d+)?/, Num::Float
+        rule %r/0x[\da-fA-F]+/, Num::Hex
+        rule %r/\d+L?/, Num::Integer
+        rule %r/\n/, Text
       end
 
       state :class do
-        rule /\s+/m, Text
+        rule %r/\s+/m, Text
         rule id, Name::Class, :pop!
       end
 
       state :dqs do
-        rule /"/, Str, :pop!
-        rule /[^\\\$"]+/, Str
+        rule %r/"/, Str, :pop!
+        rule %r/[^\\\$"]+/, Str
         mixin :string
       end
 
       state :sqs do
-        rule /'/, Str, :pop!
-        rule /[^\\\$']+/, Str
+        rule %r/'/, Str, :pop!
+        rule %r/[^\\\$']+/, Str
         mixin :string
       end
 
       state :import do
-        rule /;/, Operator, :pop!
-        rule /(?:show|hide)\b/, Keyword::Declaration
+        rule %r/;/, Operator, :pop!
+        rule %r/(?:show|hide)\b/, Keyword::Declaration
         mixin :root
       end
 
       state :string do
         mixin :interpolation
-        rule /\\[nrt\"\'\\]/, Str::Escape
+        rule %r/\\[nrt\"\'\\]/, Str::Escape
       end
 
       state :interpolation do
-        rule /\$#{id}/, Str::Interpol
-        rule /\$\{[^\}]+\}/, Str::Interpol
+        rule %r/\$#{id}/, Str::Interpol
+        rule %r/\$\{[^\}]+\}/, Str::Interpol
       end
     end
   end

data/lib/rouge/lexers/datastudio.rb

@@ -0,0 +1,138 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Datastudio < RegexLexer
+      tag 'datastudio'
+      filenames '*.job'
+      mimetypes 'text/x-datastudio'
+
+      title "Datastudio"
+      desc 'Datastudio scripting language'
+
+      id = /@?[_a-z]\w*/i
+
+      def self.sql_keywords
+        @sql_keywords ||= %w(
+          ABORT ABS ABSOLUTE ACCESS ADA ADD ADMIN AFTER AGGREGATE ALIAS
+          ALL ALLOCATE ALTER ANALYSE ANALYZE AND ANY ARE AS ASC ASENSITIVE
+          ASSERTION ASSIGNMENT ASYMMETRIC AT ATOMIC AUTHORIZATION
+          AVG BACKWARD BEFORE BEGIN BETWEEN BITVAR BIT_LENGTH BOTH
+          BREADTH BY C CACHE CALL CALLED CARDINALITY CASCADE CASCADED
+          CASE CAST CATALOG CATALOG_NAME CHAIN CHARACTERISTICS
+          CHARACTER_LENGTH CHARACTER_SET_CATALOG CHARACTER_SET_NAME
+          CHARACTER_SET_SCHEMA CHAR_LENGTH CHECK CHECKED CHECKPOINT
+          CLASS CLASS_ORIGIN CLOB CLOSE CLUSTER COALSECE COBOL COLLATE
+          COLLATION COLLATION_CATALOG COLLATION_NAME COLLATION_SCHEMA
+          COLUMN COLUMN_NAME COMMAND_FUNCTION COMMAND_FUNCTION_CODE
+          COMMENT COMMIT COMMITTED COMPLETION CONDITION_NUMBER
+          CONNECT CONNECTION CONNECTION_NAME CONSTRAINT CONSTRAINTS
+          CONSTRAINT_CATALOG CONSTRAINT_NAME CONSTRAINT_SCHEMA
+          CONSTRUCTOR CONTAINS CONTINUE CONVERSION CONVERT COPY
+          CORRESPONTING COUNT CREATE CREATEDB CREATEUSER CROSS CUBE
+          CURRENT CURRENT_DATE CURRENT_PATH CURRENT_ROLE CURRENT_TIME
+          CURRENT_TIMESTAMP CURRENT_USER CURSOR CURSOR_NAME CYCLE DATA
+          DATABASE DATETIME_INTERVAL_CODE DATETIME_INTERVAL_PRECISION
+          DAY DEALLOCATE DECLARE DEFAULT DEFAULTS DEFERRABLE DEFERRED
+          DEFINED DEFINER DELETE DELIMITER DELIMITERS DEREF DESC DESCRIBE
+          DESCRIPTOR DESTROY DESTRUCTOR DETERMINISTIC DIAGNOSTICS
+          DICTIONARY DISCONNECT DISPATCH DISTINCT DO DOMAIN DROP
+          DYNAMIC DYNAMIC_FUNCTION DYNAMIC_FUNCTION_CODE EACH ELSE
+          ENCODING ENCRYPTED END END-EXEC EQUALS ESCAPE EVERY EXCEPT
+          ESCEPTION EXCLUDING EXCLUSIVE EXEC EXECUTE EXISTING EXISTS
+          EXPLAIN EXTERNAL EXTRACT FALSE FETCH FINAL FIRST FOR FORCE
+          FOREIGN FORTRAN FORWARD FOUND FREE FREEZE FROM FULL FUNCTION
+          G GENERAL GENERATED GET GLOBAL GO GOTO GRANT GRANTED GROUP
+          GROUPING HANDLER HAVING HIERARCHY HOLD HOST IDENTITY IGNORE
+          ILIKE IMMEDIATE IMMUTABLE IMPLEMENTATION IMPLICIT IN INCLUDING
+          INCREMENT INDEX INDITCATOR INFIX INHERITS INITIALIZE INITIALLY
+          INNER INOUT INPUT INSENSITIVE INSERT INSTANTIABLE INSTEAD
+          INTERSECT INTO INVOKER IS ISNULL ISOLATION ITERATE JOIN KEY
+          KEY_MEMBER KEY_TYPE LANCOMPILER LANGUAGE LARGE LAST LATERAL
+          LEADING LEFT LENGTH LESS LEVEL LIKE LIMIT LISTEN LOAD LOCAL
+          LOCALTIME LOCALTIMESTAMP LOCATION LOCATOR LOCK LOWER MAP MATCH
+          MAX MAXVALUE MESSAGE_LENGTH MESSAGE_OCTET_LENGTH MESSAGE_TEXT
+          METHOD MIN MINUTE MINVALUE MOD MODE MODIFIES MODIFY MONTH
+          MORE MOVE MUMPS NAMES NATURAL NCLOB NEW NEXT
+          NO NOCREATEDB NOCREATEUSER NONE NOT NOTHING NOTIFY NOTNULL
+          NULL NULLABLE NULLIF OBJECT OCTET_LENGTH OF OFF OFFSET OIDS
+          OLD ON ONLY OPEN OPERATION OPERATOR OPTION OPTIONS OR ORDER
+          ORDINALITY OUT OUTER OUTPUT OVERLAPS OVERLAY OVERRIDING
+          OWNER PAD PARAMETER PARAMETERS PARAMETER_MODE PARAMATER_NAME
+          PARAMATER_ORDINAL_POSITION PARAMETER_SPECIFIC_CATALOG
+          PARAMETER_SPECIFIC_NAME PARAMATER_SPECIFIC_SCHEMA PARTIAL PASCAL
+          PENDANT PLACING PLI POSITION POSTFIX PREFIX PREORDER
+          PREPARE PRESERVE PRIMARY PRIOR PRIVILEGES PROCEDURAL PROCEDURE
+          PUBLIC READ READS RECHECK RECURSIVE REF REFERENCES REFERENCING
+          REINDEX RELATIVE RENAME REPEATABLE REPLACE RESET RESTART
+          RESTRICT RESULT RETURN RETURNED_LENGTH RETURNED_OCTET_LENGTH
+          RETURNED_SQLSTATE RETURNS REVOKE RIGHT ROLE ROLLBACK ROLLUP
+          ROUTINE ROUTINE_CATALOG ROUTINE_NAME ROUTINE_SCHEMA ROW ROWS
+          ROW_COUNT RULE SAVE_POINT SCALE SCHEMA SCHEMA_NAME SCOPE SCROLL
+          SEARCH SECOND SECURITY SELECT SELF SENSITIVE SERIALIZABLE
+          SERVER_NAME SESSION SESSION_USER SET SETOF SETS SHARE SHOW
+          SIMILAR SIMPLE SIZE SOME SOURCE SPACE SPECIFIC SPECIFICTYPE
+          SPECIFIC_NAME SQL SQLCODE SQLERROR SQLEXCEPTION SQLSTATE
+          SQLWARNINIG STABLE START STATE STATEMENT STATIC STATISTICS
+          STDIN STDOUT STORAGE STRICT STRUCTURE STYPE SUBCLASS_ORIGIN
+          SUBLIST SUBSTRING SUM SYMMETRIC SYSID SYSTEM SYSTEM_USER
+          TABLE TABLE_NAME  TEMP TEMPLATE TEMPORARY TERMINATE THAN THEN
+          TIMEZONE_HOUR TIMEZONE_MINUTE TO TOAST TRAILING
+          TRANSATION TRANSACTIONS_COMMITTED TRANSACTIONS_ROLLED_BACK
+          TRANSATION_ACTIVE TRANSFORM TRANSFORMS TRANSLATE TRANSLATION
+          TREAT TRIGGER TRIGGER_CATALOG TRIGGER_NAME TRIGGER_SCHEMA TRIM
+          TRUE TRUNCATE TRUSTED TYPE UNCOMMITTED UNDER UNENCRYPTED UNION
+          UNIQUE UNKNOWN UNLISTEN UNNAMED UNNEST UNTIL UPDATE UPPER
+          USAGE USER USER_DEFINED_TYPE_CATALOG USER_DEFINED_TYPE_NAME
+          USER_DEFINED_TYPE_SCHEMA USING VACUUM VALID VALIDATOR VALUES
+          VARIABLE VERBOSE VERSION VIEW VOLATILE WHEN WHENEVER WHERE
+          WITH WITHOUT WORK WRITE ZONE
+        )
+      end
+
+      state :whitespace do
+        rule %r/\s+/m, Text
+        rule %r(//.*?$), Comment::Single
+        rule %r(/[*].*?[*]/)m, Comment::Multiline
+      end
+
+      state :string do
+        rule %r/%(\\.|.)+?%/, Str::Escape
+        rule %r/\\"/, Str::Double
+        rule %r/"/, Str::Double, :pop!
+        rule %r/./m, Str::Double
+      end
+
+      state :string_s do
+        rule %r/%(\\.|.)+?%/, Str::Escape
+        rule %r/\\'/, Str::Single
+        rule %r/'/, Str::Single, :pop!
+        rule %r/./m, Str::Single
+      end
+
+      state :root do
+        mixin :whitespace
+
+        rule %r/^:#{id}/, Name::Label
+        rule %r/@#{id}(\.#{id})?/m, Name::Entity
+        rule %r/%(\\.|.)+?%/, Name::Variable
+        rule %r/[~!%^&*()+=|\[\]{}:;,.<>\/?-]/, Punctuation
+        rule %r/"/, Str::Double, :string
+        rule %r/'/, Str::Single, :string_s
+        rule %r/\d(\.\d*)?/i, Num
+        rule %r/#{id}(?=\s*[(])/, Name::Function
+        rule id do |m|
+          name = m[0].upcase
+          
+          if self.class.sql_keywords.include? name
+            token Keyword
+          else
+            token Name
+          end
+        end
+      end
+
+    end
+  end
+end