rouge-alda 3.3.0

data/lib/rouge/lexers/sqf.rb

@@ -0,0 +1,109 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class SQF < RegexLexer
+      tag "sqf"
+      filenames "*.sqf"
+
+      title "SQF"
+      desc "Status Quo Function, a Real Virtuality engine scripting language"
+
+      def self.wordoperators
+        @wordoperators ||= Set.new %w(
+          and or not
+        )
+      end
+
+      def self.initializers
+        @initializers ||= Set.new %w(
+          private param params
+        )
+      end
+
+      def self.controlflow
+        @controlflow ||= Set.new %w(
+          if then else exitwith switch do case default while for from to step
+          foreach
+        )
+      end
+
+      def self.constants
+        @constants ||= Set.new %w(
+          true false player confignull controlnull displaynull grpnull
+          locationnull netobjnull objnull scriptnull tasknull teammembernull
+        )
+      end
+
+      def self.namespaces
+        @namespaces ||= Set.new %w(
+          currentnamespace missionnamespace parsingnamespace profilenamespace
+          uinamespace
+        )
+      end
+
+      def self.diag_commands
+        @diag_commands ||= Set.new %w(
+          diag_activemissionfsms diag_activesqfscripts diag_activesqsscripts
+          diag_activescripts diag_captureframe diag_captureframetofile
+          diag_captureslowframe diag_codeperformance diag_drawmode diag_enable
+          diag_enabled diag_fps diag_fpsmin diag_frameno diag_lightnewload
+          diag_list diag_log diag_logslowframe diag_mergeconfigfile
+          diag_recordturretlimits diag_setlightnew diag_ticktime diag_toggle
+        )
+      end
+
+      def self.commands
+        load Pathname.new(__FILE__).dirname.join("sqf/commands.rb")
+        @commands = self.commands
+      end
+
+      state :root do
+        # Whitespace
+        rule %r"\s+", Text
+
+        # Preprocessor instructions
+        rule %r"/\*.*?\*/"m, Comment::Multiline
+        rule %r"//.*\n", Comment::Single
+        rule %r"#(define|undef|if(n)?def|else|endif|include)", Comment::Preproc
+        rule %r"\\\r?\n", Comment::Preproc
+        rule %r"__(EVAL|EXEC|LINE__|FILE__)", Name::Builtin
+
+        # Literals
+        rule %r"\".*?\"", Literal::String
+        rule %r"'.*?'", Literal::String
+        rule %r"(\$|0x)[0-9a-fA-F]+", Literal::Number::Hex
+        rule %r"[0-9]+(\.)?(e[0-9]+)?", Literal::Number::Float
+
+        # Symbols
+        rule %r"[\!\%\&\*\+\-\/\<\=\>\^\|\#]", Operator
+        rule %r"[\(\)\{\}\[\]\,\:\;]", Punctuation
+
+        # Identifiers (variables and functions)
+        rule %r"[a-zA-Z0-9_]+" do |m|
+          name = m[0].downcase
+          if self.class.wordoperators.include? name
+            token Operator::Word
+          elsif self.class.initializers.include? name
+            token Keyword::Declaration
+          elsif self.class.controlflow.include? name
+            token Keyword::Reserved
+          elsif self.class.constants.include? name
+            token Keyword::Constant
+          elsif self.class.namespaces.include? name
+            token Keyword::Namespace
+          elsif self.class.diag_commands.include? name
+            token Name::Function
+          elsif self.class.commands.include? name
+            token Name::Function
+          elsif %r"_.+" =~ name
+            token Name::Variable
+          else
+            token Name::Variable::Global
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rouge/lexers/sql.rb

@@ -0,0 +1,141 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+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 /--.*/, 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,182 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+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 mutating none nonmutating operator override postfix precedence prefix set unowned weak willSet throws rethrows precedencegroup
+      )
+
+      declarations = Set.new %w(
+        class deinit enum convenience extension final func import init internal lazy let optional private protocol public required static struct subscript typealias var dynamic indirect associatedtype open fileprivate
+      )
+
+      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
+        mixin :has_comments
+      end
+
+      state :whitespace do
+        rule /\n+/m, Text, :bol
+        rule %r(\/\/.*?$), Comment::Single, :bol
+        mixin :inline_whitespace
+      end
+
+      state :has_comments do
+        rule %r(/[*]), Comment::Multiline, :nested_comment
+      end
+
+      state :nested_comment do
+        mixin :has_comments
+        rule %r([*]/), Comment::Multiline, :pop!
+        rule %r([^*/]+)m, Comment::Multiline
+        rule /./, Comment::Multiline
+      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 /(#(?:selector|keyPath)\()([^)]+?(?:[(].*?[)])?)(\))/ do
+          groups Keyword::Declaration, Name::Function, Keyword::Declaration
+        end
+        
+        rule /#(line|file|column|function|dsohandle)/, Keyword::Declaration
+
+        rule /(let|var)\b(\s*)(#{id})/ do
+          groups Keyword, Text, Name::Variable
+        end
+
+        rule /(let|var)\b(\s*)([(])/ do
+          groups Keyword, Text, Punctuation
+          push :tuple
+        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[?!]?(?=\s)/, Keyword
+        rule /try[!]?(?=\s)/, 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
+
+        rule /(`)(#{id})(`)/ do
+          groups Punctuation, Name::Variable, Punctuation
+        end
+      end
+
+      state :tuple do
+        rule /(#{id})/, Name::Variable
+        rule /(`)(#{id})(`)/ do
+            groups Punctuation, Name::Variable, Punctuation
+        end
+        rule /,/, Punctuation
+        rule /[(]/, Punctuation, :push
+        rule /[)]/, Punctuation, :pop!
+        mixin :inline_whitespace
+      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/tap.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Tap < RegexLexer
+      title 'TAP'
+      desc 'Test Anything Protocol'
+      tag 'tap'
+      aliases 'tap'
+      filenames '*.tap'
+
+      mimetypes 'text/x-tap', 'application/x-tap'
+
+      state :root do
+        # A TAP version may be specified.
+        rule /^TAP version \d+\n/, Name::Namespace
+
+        # Specify a plan with a plan line.
+        rule /^1\.\.\d+/, Keyword::Declaration, :plan
+
+        # A test failure
+        rule /^(not ok)([^\S\n]*)(\d*)/ do
+          groups Generic::Error, Text, Literal::Number::Integer
+          push :test
+        end
+
+        # A test success
+        rule /^(ok)([^\S\n]*)(\d*)/ do
+          groups Keyword::Reserved, Text, Literal::Number::Integer
+          push :test
+        end
+
+        # Diagnostics start with a hash.
+        rule /^#.*\n/, Comment
+
+        # TAP's version of an abort statement.
+        rule /^Bail out!.*\n/, Generic::Error
+
+        # # TAP ignores any unrecognized lines.
+        rule /^.*\n/, Text
+      end
+
+      state :plan do
+        # Consume whitespace (but not newline).
+        rule /[^\S\n]+/, Text
+
+        # A plan may have a directive with it.
+        rule /#/, Comment, :directive
+
+        # Or it could just end.
+        rule /\n/, Comment, :pop!
+
+        # Anything else is wrong.
+        rule /.*\n/, Generic::Error, :pop!
+      end
+
+      state :test do
+        # Consume whitespace (but not newline).
+        rule /[^\S\n]+/, Text
+
+        # A test may have a directive with it.
+        rule /#/, Comment, :directive
+
+        rule /\S+/, Text
+
+        rule /\n/, Text, :pop!
+      end
+
+      state :directive do
+        # Consume whitespace (but not newline).
+        rule /[^\S\n]+/, Comment
+
+        # Extract todo items.
+        rule /(?i)\bTODO\b/, Comment::Preproc
+
+        # Extract skip items.
+        rule /(?i)\bSKIP\S*/, Comment::Preproc
+
+        rule /\S+/, Comment
+
+        rule /\n/ do
+          token Comment
+          pop! 2
+        end
+      end
+    end
+  end
+end
+