gitlab-rouge 1.9.2

data/lib/rouge/lexers/sql.rb

@@ -0,0 +1,140 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class SQL < RegexLexer
+      title "SQL"
+      desc "Structured Query Language, for relational databases"
+      tag 'sql'
+      filenames '*.sql'
+      mimetypes 'text/x-sql'
+
+      def self.keywords
+        @keywords ||= Set.new %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 NATIONAL NATURAL NCHAR 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 PRECISION 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
+          TIMESTAMP 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 YEAR ZONE
+        )
+      end
+
+      state :root do
+        rule /\s+/m, Text
+        rule /--.*?\n/, Comment::Single
+        rule %r(/\*), Comment::Multiline, :multiline_comments
+        rule /\d+/, Num::Integer
+        rule /'/, Str::Single, :single_string
+        rule /"/, Name::Variable, :double_string
+        rule /`/, Name::Variable, :backtick
+
+        rule /\w[\w\d]*/ do |m|
+          if self.class.keywords.include? m[0].upcase
+            token Keyword
+          else
+            token Name
+          end
+        end
+
+        rule %r([+*/<>=~!@#%^&|?^-]), Operator
+        rule /[;:()\[\],.]/, Punctuation
+      end
+
+      state :multiline_comments do
+        rule %r(/[*]), Comment::Multiline, :multiline_comments
+        rule %r([*]/), Comment::Multiline, :pop!
+        rule %r([^/*]+), Comment::Multiline
+        rule %r([/*]), Comment::Multiline
+      end
+
+      state :backtick do
+        rule /\\./, Str::Escape
+        rule /``/, Str::Escape
+        rule /`/, Name::Variable, :pop!
+        rule /[^\\`]+/, Name::Variable
+      end
+
+      state :single_string do
+        rule /\\./, Str::Escape
+        rule /''/, Str::Escape
+        rule /'/, Str::Single, :pop!
+        rule /[^\\']+/, Str::Single
+      end
+
+      state :double_string do
+        rule /\\./, Str::Escape
+        rule /""/, Str::Escape
+        rule /"/, Name::Variable, :pop!
+        rule /[^\\"]+/, Name::Variable
+      end
+    end
+  end
+end

data/lib/rouge/lexers/swift.rb

@@ -0,0 +1,144 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class Swift < RegexLexer
+      tag 'swift'
+      filenames '*.swift'
+
+      title "Swift"
+      desc 'Multi paradigm, compiled programming language developed by Apple for iOS and OS X development. (developer.apple.com/swift)'
+
+      id_head = /_|(?!\p{Mc})\p{Alpha}|[^\u0000-\uFFFF]/
+      id_rest = /[\p{Alnum}_]|[^\u0000-\uFFFF]/
+      id = /#{id_head}#{id_rest}*/
+
+      keywords = Set.new %w(
+        break case continue default do else fallthrough if in for return switch where while try catch throw guard defer repeat
+
+        as dynamicType is new super self Self Type __COLUMN__ __FILE__ __FUNCTION__ __LINE__
+
+        associativity didSet get infix inout left mutating none nonmutating operator override postfix precedence prefix right set unowned weak willSet throws rethrows
+      )
+
+      declarations = Set.new %w(
+        class deinit enum extension final func import init internal lazy let optional private protocol public required static struct subscript typealias var dynamic
+      )
+
+      constants = Set.new %w(
+        true false nil
+      )
+
+      start { push :bol }
+
+      # beginning of line
+      state :bol do
+        rule /#.*/, Comment::Preproc
+
+        mixin :inline_whitespace
+
+        rule(//) { pop! }
+      end
+
+      state :inline_whitespace do
+        rule /\s+/m, Text
+        rule %r((?<re>\/\*(?:(?>[^\/\*\*\/]+)|\g<re>)*\*\/))m, Comment::Multiline
+      end
+
+      state :whitespace do
+        rule /\n+/m, Text, :bol
+        rule %r(\/\/.*?$), Comment::Single, :bol
+        mixin :inline_whitespace
+      end
+
+      state :root do
+        mixin :whitespace
+        rule /\$(([1-9]\d*)?\d)/, Name::Variable
+
+        rule %r{[()\[\]{}:;,?]}, Punctuation
+        rule %r([-/=+*%<>!&|^.~]+), Operator
+        rule /@?"/, Str, :dq
+        rule /'(\\.|.)'/, Str::Char
+        rule /(\d+\*|\d*\.\d+)(e[+-]?[0-9]+)?/i, Num::Float
+        rule /\d+e[+-]?[0-9]+/i, Num::Float
+        rule /0_?[0-7]+(?:_[0-7]+)*/, Num::Oct
+        rule /0x[0-9A-Fa-f]+(?:_[0-9A-Fa-f]+)*/, Num::Hex
+        rule /0b[01]+(?:_[01]+)*/, Num::Bin
+        rule %r{[\d]+(?:_\d+)*}, Num::Integer
+
+        rule /@#{id}(\([^)]+\))?/, Keyword::Declaration
+
+        rule /(private|internal)(\([ ]*)(\w+)([ ]*\))/ do |m|
+          if m[3] == 'set'
+            token Keyword::Declaration
+          else
+            groups Keyword::Declaration, Keyword::Declaration, Error, Keyword::Declaration
+          end
+        end
+
+        rule /(unowned\([ ]*)(\w+)([ ]*\))/ do |m|
+          if m[2] == 'safe' || m[2] == 'unsafe'
+            token Keyword::Declaration
+          else
+            groups Keyword::Declaration, Error, Keyword::Declaration
+          end
+        end
+        
+        rule /#available\([^)]+\)/, Keyword::Declaration
+
+        rule /(let|var)\b(\s*)(#{id})/ do
+          groups Keyword, Text, Name::Variable
+        end
+
+        rule /(?!\b(if|while|for|private|internal|unowned|switch|case)\b)\b#{id}(?=(\?|!)?\s*[(])/ do |m|
+          if m[0] =~ /^[[:upper:]]/
+            token Keyword::Type
+          else
+            token Name::Function
+          end
+        end
+        
+        rule /as[?!]?/, Keyword
+        rule /try[!]?/, Keyword
+
+        rule /(#?(?!default)(?![[:upper:]])#{id})(\s*)(:)/ do
+          groups Name::Variable, Text, Punctuation
+        end
+
+        rule id do |m|
+          if keywords.include? m[0]
+            token Keyword
+          elsif declarations.include? m[0]
+            token Keyword::Declaration
+          elsif constants.include? m[0]
+            token Keyword::Constant
+          elsif m[0] =~ /^[[:upper:]]/
+            token Keyword::Type
+          else
+            token Name
+          end
+        end
+      end
+
+      state :dq do
+        rule /\\[\\0tnr'"]/, Str::Escape
+        rule /\\[(]/, Str::Escape, :interp
+        rule /\\u\{\h{1,8}\}/, Str::Escape
+        rule /[^\\"]+/, Str
+        rule /"/, Str, :pop!
+      end
+
+      state :interp do
+        rule /[(]/, Punctuation, :interp_inner
+        rule /[)]/, Str::Escape, :pop!
+        mixin :root
+      end
+
+      state :interp_inner do
+        rule /[(]/, Punctuation, :push
+        rule /[)]/, Punctuation, :pop!
+        mixin :root
+      end
+    end
+  end
+end

data/lib/rouge/lexers/tcl.rb

@@ -0,0 +1,192 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class TCL < RegexLexer
+      title "Tcl"
+      desc "The Tool Command Language (tcl.tk)"
+      tag 'tcl'
+      filenames '*.tcl'
+      mimetypes 'text/x-tcl', 'text/x-script.tcl', 'application/x-tcl'
+
+      def self.analyze_text(text)
+        return 1 if text.shebang? 'tclsh'
+        return 1 if text.shebang? 'wish'
+        return 1 if text.shebang? 'jimsh'
+      end
+
+      KEYWORDS = %w(
+        after apply array break catch continue elseif else error
+        eval expr for foreach global if namespace proc rename return
+        set switch then trace unset update uplevel upvar variable
+        vwait while
+      )
+
+      BUILTINS = %w(
+        append bgerror binary cd chan clock close concat dde dict
+        encoding eof exec exit fblocked fconfigure fcopy file
+        fileevent flush format gets glob history http incr info interp
+        join lappend lassign lindex linsert list llength load loadTk
+        lrange lrepeat lreplace lreverse lsearch lset lsort mathfunc
+        mathop memory msgcat open package pid pkg::create pkg_mkIndex
+        platform platform::shell puts pwd re_syntax read refchan
+        regexp registry regsub scan seek socket source split string
+        subst tell time tm unknown unload
+      )
+
+      OPEN =  %w| \( \[ \{ " |
+      CLOSE = %w| \) \] \} |
+      ALL = OPEN + CLOSE
+      END_LINE = CLOSE + %w(; \n)
+      END_WORD = END_LINE + %w(\s)
+
+      CHARS =     lambda { |list| Regexp.new %/[#{list.join}]/  }
+      NOT_CHARS = lambda { |list| Regexp.new %/[^#{list.join}]/ }
+
+      state :word do
+        rule /\{\*\}/, Keyword
+
+        mixin :brace_abort
+        mixin :interp
+        rule /\{/, Punctuation, :brace
+        rule /\(/, Punctuation,   :paren
+        rule /"/,  Str::Double, :string
+        rule /#{NOT_CHARS[END_WORD]}+?(?=#{CHARS[OPEN+['\\\\']]})/, Text
+      end
+
+      def self.gen_command_state(name='')
+        state(:"command#{name}") do
+          mixin :word
+
+          rule /##{NOT_CHARS[END_LINE]}+/, Comment::Single
+
+          rule /(?=#{CHARS[END_WORD]})/ do
+            push :"params#{name}"
+          end
+
+          rule /#{NOT_CHARS[END_WORD]}+/ do |m|
+            if KEYWORDS.include? m[0]
+              token Keyword
+            elsif BUILTINS.include? m[0]
+              token Name::Builtin
+            else
+              token Text
+            end
+          end
+
+          mixin :whitespace
+        end
+      end
+
+      def self.gen_delimiter_states(name, close, opts={})
+        gen_command_state("_in_#{name}")
+
+        state :"params_in_#{name}" do
+          rule close do
+            token Punctuation
+            pop! 2
+          end
+
+          # mismatched delimiters.  Braced strings with mismatched
+          # closing delimiters should be okay, since this is standard
+          # practice, like {]]]]}
+          if opts[:strict]
+            rule CHARS[CLOSE - [close]], Error
+          else
+            rule CHARS[CLOSE - [close]], Text
+          end
+
+          mixin :params
+        end
+
+        state name do
+          rule close, Punctuation, :pop!
+          mixin :"command_in_#{name}"
+        end
+      end
+
+
+      # tcl is freaking impossible.  If we're in braces and we encounter
+      # a close brace, we have to drop everything and close the brace.
+      # This is so silly things like {abc"def} and {abc]def} don't b0rk
+      # everything after them.
+
+      # TODO: TCL seems to have this aborting behavior quite a lot.
+      # such things as [ abc" ] are a runtime error, but will still
+      # parse.  Currently something like this will muck up the lex.
+      state :brace_abort do
+        rule /}/ do
+          if in_state? :brace
+            pop! until state? :brace
+            pop!
+            token Punctuation
+          else
+            token Error
+          end
+        end
+      end
+
+      state :params do
+        rule /;/, Punctuation, :pop!
+        rule /\n/, Text, :pop!
+        rule /else|elseif|then/, Keyword
+        mixin :word
+        mixin :whitespace
+        rule /#{NOT_CHARS[END_WORD]}+/, Text
+      end
+
+      gen_delimiter_states :brace,   /\}/, :strict => false
+      gen_delimiter_states :paren,   /\)/, :strict => true
+      gen_delimiter_states :bracket, /\]/, :strict => true
+      gen_command_state
+
+      state :root do
+        mixin :command
+      end
+
+      state :whitespace do
+        # not a multiline regex because we want to capture \n sometimes
+        rule /\s+/, Text
+      end
+
+      state :interp do
+        rule /\[/, Punctuation, :bracket
+        rule /\$[a-z0-9.:-]+/, Name::Variable
+        rule /\$\{.*?\}/m, Name::Variable
+        rule /\$/, Text
+
+        # escape sequences
+        rule /\\[0-7]{3}/, Str::Escape
+        rule /\\x[0-9a-f]{2}/i, Str::Escape
+        rule /\\u[0-9a-f]{4}/i, Str::Escape
+        rule /\\./m, Str::Escape
+      end
+
+      state :string do
+        rule /"/, Str::Double, :pop!
+        mixin :interp
+        rule /[^\\\[\$"{}]+/m, Str::Double
+
+        # strings have to keep count of their internal braces, to support
+        # for example { "{ }" }.
+        rule /{/ do
+          @brace_count ||= 0
+          @brace_count += 1
+
+          token Str::Double
+        end
+
+        rule /}/ do
+          if in_state? :brace and @brace_count.to_i == 0
+            pop! until state? :brace
+            pop!
+            token Punctuation
+          else
+            @brace_count -= 1
+            token Str::Double
+          end
+        end
+      end
+    end
+  end
+end