rouge 3.18.0

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

data/lib/rouge/lexers/diff.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Diff < RegexLexer
+      title 'diff'
+      desc 'Lexes unified diffs or patches'
+
+      tag 'diff'
+      aliases 'patch', 'udiff'
+      filenames '*.diff', '*.patch'
+      mimetypes 'text/x-diff', 'text/x-patch'
+
+      def self.detect?(text)
+        return true if text.start_with?('Index: ')
+        return true if text =~ %r(\Adiff[^\n]*?\ba/[^\n]*\bb/)
+        return true if text =~ /(---|[+][+][+]).*?\n(---|[+][+][+])/
+      end
+
+      state :root do
+        rule(/^ .*$\n?/, Text)
+        rule(/^---$\n?/, Punctuation)
+        rule(/^[+>]+.*$\n?/, Generic::Inserted)
+        rule(/^\+.*$\n?/, Generic::Inserted)
+        rule(/^[-<]+.*$\n?/, Generic::Deleted)
+        rule(/^!.*$\n?/, Generic::Strong)
+        rule(/^([Ii]ndex|diff).*$\n?/, Generic::Heading)
+        rule(/^(@@[^@]*@@)([^\n]*\n)/) do
+          groups Punctuation, Text
+        end
+        rule(/^\w.*$\n?/, Punctuation)
+        rule(/^=.*$\n?/, Generic::Heading)
+        rule(/\s.*$\n?/, Text)
+      end
+    end
+  end
+end

data/lib/rouge/lexers/digdag.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'set'
+module Rouge
+  module Lexers
+    load_lexer 'yaml.rb'
+
+    class Digdag < YAML
+      title 'digdag'
+      desc 'A simple, open source, multi-cloud workflow engine (https://www.digdag.io/)'
+      tag 'digdag'
+      filenames '*.dig'
+
+      mimetypes 'application/x-digdag'
+
+      # http://docs.digdag.io/operators.html
+      # as of digdag v0.9.10
+      KEYWORD_PATTERN = Regexp.union(%w(
+        call
+        require
+        loop
+        for_each
+        if
+        fail
+        echo
+
+        td
+        td_run
+        td_ddl
+        td_load
+        td_for_each
+        td_wait
+        td_wait_table
+        td_partial_delete
+        td_table_export
+
+        pg
+
+        mail
+        http
+        s3_wait
+        redshift
+        redshift_load
+        redshift_unload
+        emr
+
+        gcs_wait
+        bq
+        bq_ddl
+        bq_extract
+        bq_load
+
+        sh
+        py
+        rb
+        embulk
+      ).map { |name| "#{name}>"} + %w(
+        _do
+        _parallel
+      ))
+
+      prepend :block_nodes do
+        rule %r/(#{KEYWORD_PATTERN})(:)(?=\s|$)/ do |m|
+          groups Keyword::Reserved, Punctuation::Indicator
+          set_indent m[0], :implicit => true
+        end
+      end
+    end
+  end
+end

data/lib/rouge/lexers/docker.rb

@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Docker < RegexLexer
+      title "Docker"
+      desc "Dockerfile syntax"
+      tag 'docker'
+      aliases 'dockerfile'
+      filenames 'Dockerfile', '*.Dockerfile', '*.docker', 'Dockerfile_*'
+      mimetypes 'text/x-dockerfile-config'
+
+      KEYWORDS = %w(
+        FROM MAINTAINER CMD LABEL EXPOSE ENV ADD COPY ENTRYPOINT VOLUME USER WORKDIR ARG STOPSIGNAL HEALTHCHECK SHELL
+      ).join('|')
+
+      start { @shell = Shell.new(@options) }
+
+      state :root do
+        rule %r/\s+/, Text
+
+        rule %r/^(ONBUILD)(\s+)(#{KEYWORDS})(.*)/io do
+          groups Keyword, Text::Whitespace, Keyword, Str
+        end
+
+        rule %r/^(#{KEYWORDS})\b(.*)/io do
+          groups Keyword, Str
+        end
+
+        rule %r/#.*?$/, Comment
+
+        rule %r/^(ONBUILD\s+)?RUN(\s+)/i do
+          token Keyword
+          push :run
+          @shell.reset!
+        end
+
+        rule %r/\w+/, Text
+        rule %r/[^\w]+/, Text
+        rule %r/./, Text
+      end
+
+      state :run do
+        rule %r/\n/, Text, :pop!
+        rule %r/\\./m, Str::Escape
+        rule(/(\\.|[^\n\\])+/) { delegate @shell }
+      end
+    end
+  end
+end

data/lib/rouge/lexers/dot.rb

@@ -0,0 +1,69 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Dot < RegexLexer
+      title "DOT"
+      desc "graph description language"
+
+      tag 'dot'
+      filenames '*.dot'
+      mimetypes 'text/vnd.graphviz'
+
+      start do
+        @html = HTML.new(options)
+      end
+
+      state :comments_and_whitespace do
+        rule %r/\s+/, Text
+        rule %r(#.*), Comment::Single
+        rule %r(//.*?$), Comment::Single
+        rule %r(/(\\\n)?[*].*?[*](\\\n)?/)m, Comment::Multiline
+      end
+
+      state :html do
+        rule %r/[^<>]+/ do
+          delegate @html
+        end
+        rule %r/<.+?>/m do
+          delegate @html
+        end
+        rule %r/>/, Punctuation, :pop!
+      end
+
+      state :ID do
+        rule %r/([a-zA-Z][a-zA-Z_0-9]*)(\s*)(=)/ do |m|
+          token Name, m[1]
+          token Text, m[2]
+          token Punctuation, m[3]
+        end
+        rule %r/[a-zA-Z][a-zA-Z_0-9]*/, Name::Variable
+        rule %r/([0-9]+)?\.[0-9]+/, Num::Float
+        rule %r/[0-9]+/, Num::Integer
+        rule %r/"(\\"|[^"])*"/, Str::Double
+        rule %r/</ do
+          token Punctuation
+          @html.reset!
+          push :html
+        end
+      end
+
+      state :a_list do
+        mixin :comments_and_whitespace
+        mixin :ID
+        rule %r/[=;,]/, Punctuation
+        rule %r/\]/, Operator, :pop!
+      end
+
+      state :root do
+        mixin :comments_and_whitespace
+        rule %r/\b(strict|graph|digraph|subgraph|node|edge)\b/i, Keyword
+        rule %r/[{};:=]/, Punctuation
+        rule %r/-[->]/, Operator
+        rule %r/\[/, Operator, :a_list
+        mixin :ID
+      end
+    end
+  end
+end

data/lib/rouge/lexers/ecl.rb

@@ -0,0 +1,175 @@
+# -*- codding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class ECL < RegexLexer
+      tag 'ecl'
+      filenames '*.ecl'
+      mimetypes 'application/x-ecl'
+
+      title "ECL"
+      desc "Enterprise Control Language (hpccsystems.com)"
+
+      id = /(#?)\b([a-z_][\w]*?)(\d*)\b/i
+
+      def self.class_first
+        @class_first ||= Set.new %w(
+          file date str math metaphone metaphone3 uni audit blas system
+        )
+      end
+
+      def self.class_second
+        @class_second ||= Set.new %w(
+          debug email job log thorlib util workunit
+        )
+      end
+
+      def self.functions
+        @functions ||= Set.new %w(
+          abs acos aggregate allnodes apply ascii asin asstring atan _token ave
+          case catch choose choosen choosesets clustersize combine correlation
+          cos cosh count covariance cron dataset dedup define denormalize
+          dictionary distribute distributed distribution ebcdic enth error
+          evaluate event eventextra eventname exists exp failcode failmessage
+          fetch fromunicode fromxml getenv getisvalid global graph group hash
+          hashcrc having httpcall httpheader if iff index intformat isvalid
+          iterate join keyunicode length library limit ln local log loop map
+          matched matchlength matchposition matchtext matchunicode max merge
+          mergejoin min nofold nolocal nonempty normalize parse pipe power
+          preload process project pull random range rank ranked realformat
+          recordof regexfind regexreplace regroup rejected rollup round roundup
+          row rowdiff sample set sin sinh sizeof soapcall sort sorted sqrt
+          stepped stored sum table tan tanh thisnode topn tounicode toxml
+          transfer transform trim truncate typeof ungroup unicodeorder variance
+          which workunit xmldecode xmlencode xmltext xmlunicode apply assert
+          build buildindex evaluate fail keydiff keypatch loadxml nothor notify
+          output parallel sequential soapcall wait
+        )
+      end
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          and or in not all any as from atmost before best between case const
+          counter csv descend encrypt end endmacro enum except exclusive expire
+          export extend fail few first flat full function functionmacro group
+          heading hole ifblock import joined keep keyed last left limit load
+          local locale lookup many maxcount maxlength _token module interface
+          named nocase noroot noscan nosort of only opt outer overwrite packed
+          partition penalty physicallength pipe quote record repeat return
+          right rows scan self separator service shared skew skip sql store
+          terminator thor threshold token transform trim type unicodeorder
+          unsorted validate virtual whole wild within xml xpath after cluster
+          compressed compression default encoding escape fileposition forward
+          grouped inner internal linkcounted literal lzw mofn multiple
+          namespace wnotrim noxpath onfail prefetch retry rowset scope smart
+          soapaction stable timelimit timeout unordered unstable update use
+          width
+        )
+      end
+
+      def self.template
+        @template ||= Set.new %w(
+          append apply break constant debug declare demangle else elseif end
+          endregion error expand export exportxml for forall getdatatype if
+          ifdefined inmodule isdefined isvalid line link loop mangle onwarning
+          option region set stored text trace uniquename warning webservice
+          workunit loadxml
+        )
+      end
+
+      def self.type
+        @type ||= Set.new %w(
+          ascii big_endian boolean data decimal ebcdic grouped integer
+          linkcounted pattern qstring real record rule set of streamed string
+          token udecimal unicode utf8 unsigned varstring varunicode
+        )
+      end
+
+      def self.typed
+        @typed ||= Set.new %w(
+          data string qstring varstring varunicode unicode utf8
+        )
+      end
+
+      state :single_quote do
+        rule %r([xDQUV]?'([^'\\]*(?:\\.[^'\\]*)*)'), Str::Single
+        rule %r/\\(x\\h{2}|[0-2][0-7]{,2}|3[0-6][0-7]?|37[0-7]?|[4-7][0-7]?|.|$)/, Text
+      end
+
+      state :inline_whitespace do
+        rule %r/[ \t\r]+/, Text
+        rule %r/\\\n/, Text # line continuation
+        rule %r(/[*].*?[*]/)m, Comment::Multiline
+      end
+
+      state :whitespace do
+        rule %r/\n+/m, Text
+        rule %r(//.*), Comment::Single
+        mixin :inline_whitespace
+      end
+
+      state :root do
+        mixin :whitespace
+        mixin :single_quote
+
+        rule %r(\b(?i:(and|not|or|in))\b), Operator::Word
+        rule %r([:=|>|<|<>|/|\\|\+|-|=]), Operator
+        rule %r([\[\]{}();,\&,\.,\%]), Punctuation
+
+        rule %r(\b(?i:(beginc\+\+.*?endc\+\+)))m, Str::Single
+        rule %r(\b(?i:(embed.*?endembed)))m, Str::Single
+
+        rule %r(\b(\w+)\.(\w+)\.(\w+)) do |m|
+          if m[1] == "std" &&
+             self.class.class_first.include?(m[2]) &&
+             self.class.class_second.include?(m[3])
+            token Name::Class
+          else
+            token Name::Variable
+          end
+        end
+
+        rule %r(\b(?i:(u)?decimal)(\d+(_\d+)?)\b), Keyword::Type
+
+        rule %r/\d+\.\d+(e[\+\-]?\d+)?/i, Num::Float
+        rule %r/x[0-9a-f]+/i, Num::Hex
+
+        rule %r/0x[0-9a-f]+/i, Num::Hex
+        rule %r/0[0-9a-f]+x/i, Num::Hex
+        rule %r(0[bB][01]+), Num::Bin
+        rule %r([01]+[bB]), Num::Bin
+        rule %r(\d+), Num::Integer
+
+        rule id do |m|
+          name_only = m[2].downcase
+          name      = name_only + m[3]
+          number    = (m[3] == "") ? nil : m[3].to_i
+          if m[1] == "#"
+            if self.class.template.include? name
+              token Keyword::Type
+            else
+              token Error
+            end
+          elsif self.class.typed.include?(name_only) && number != nil
+            token Keyword::Type
+          elsif self.class.type.include? name
+            token Keyword::Type
+          elsif self.class.keywords.include? name
+            token Keyword
+          elsif self.class.functions.include? name
+            token Name::Function
+          elsif ["integer", "unsigned"].include?(name_only) && (1..8).cover?(number)
+            token Keyword::Type
+          elsif name_only == "real" && [4, 8].include?(number)
+            token Keyword::Type
+          elsif ["true", "false"].include? name
+            token Keyword::Constant
+          else
+            token Name::Other
+          end
+        end
+      end
+    end
+  end
+end