rouge 3.2.0 → 3.18.0

data/lib/rouge/lexers/kotlin.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers
@@ -18,31 +19,17 @@ module Rouge
         external false final finally for fun get if import in infix
         inline inner interface internal is lateinit noinline null
         object open operator out override package private protected
-        public reified return sealed set super tailrec this throw
-        true try typealias typeof val var vararg when where while
-        yield
+        public reified return sealed set super suspend tailrec this
+        throw true try typealias typeof val var vararg when where
+        while yield
       )
 
-      name = %r'@?[_\p{Lu}\p{Ll}\p{Lt}\p{Lm}\p{Nl}][\p{Lu}\p{Ll}\p{Lt}\p{Lm}\p{Nl}\p{Nd}\p{Pc}\p{Cf}\p{Mn}\p{Mc}]*'
+      name_chars = %r'[-_\p{Lu}\p{Ll}\p{Lt}\p{Lm}\p{Nl}\p{Nd}\p{Pc}\p{Cf}\p{Mn}\p{Mc}]*'
 
-      id = %r'(#{name}|`#{name}`)'
+      class_name = %r'`?[\p{Lu}]#{name_chars}`?'
+      name = %r'`?[_\p{Lu}\p{Ll}\p{Lt}\p{Lm}\p{Nl}]#{name_chars}`?'
 
       state :root do
-        rule %r'^\s*\[.*?\]', Name::Attribute
-        rule %r'[^\S\n]+', Text
-        rule %r'\\\n', Text # line continuation
-        rule %r'//.*?$', Comment::Single
-        rule %r'/[*].*?[*]/'m, Comment::Multiline
-        rule %r'\n', Text
-        rule %r'::|!!|\?[:.]', Operator
-        rule %r"(\.\.)", Operator
-        rule %r'[~!%^&*()+=|\[\]:;,.<>/?-]', Punctuation
-        rule %r'[{}]', Punctuation
-        rule %r'@"(""|[^"])*"'m, Str
-        rule %r'""".*?"""'m, Str
-        rule %r'"(\\\\|\\"|[^"\n])*["\n]'m, Str
-        rule %r"'\\.'|'[^\\]'", Str::Char
-        rule %r"[0-9](\.[0-9]+)?([eE][+-][0-9]+)?[flFL]?|0[xX][0-9a-fA-F]+[Ll]?", Num
         rule %r'\b(companion)(\s+)(object)\b' do
           groups Keyword, Text, Keyword
         end
@@ -50,29 +37,94 @@ module Rouge
           groups Keyword::Declaration, Text
           push :class
         end
+        rule %r'\b(fun)(\s+)' do
+          groups Keyword, Text
+          push :function
+        end
         rule %r'\b(package|import)(\s+)' do
           groups Keyword, Text
           push :package
         end
+        rule %r'\b(val|var)(\s+)(\()' do
+          groups Keyword::Declaration, Text, Punctuation
+          push :destructure
+        end
         rule %r'\b(val|var)(\s+)' do
           groups Keyword::Declaration, Text
           push :property
         end
-        rule %r/\bfun\b/, Keyword
-        rule /\b(?:#{keywords.join('|')})\b/, Keyword
-        rule id, Name
+        rule %r'(return|continue|break|this|super)(@#{name})?' do
+          groups Keyword, Name::Decorator
+        end
+        rule %r'\bfun\b', Keyword
+        rule %r'\b(?:#{keywords.join('|')})\b', Keyword
+        rule %r'^\s*\[.*?\]', Name::Attribute
+        rule %r'[^\S\n]+', Text
+        rule %r'\\\n', Text # line continuation
+        rule %r'//.*?$', Comment::Single
+        rule %r'/[*].*[*]/', Comment::Multiline # single line block comment
+        rule %r'/[*].*', Comment::Multiline, :comment # multiline block comment
+        rule %r'\n', Text
+        rule %r'::|!!|\?[:.]', Operator
+        rule %r"(\.\.)", Operator
+        rule %r'[~!%^&*()+=|\[\]:;,.<>/?-]', Punctuation
+        rule %r'[{}]', Punctuation
+        rule %r'@"(""|[^"])*"'m, Str
+        rule %r'""".*?"""'m, Str
+        rule %r'"(\\\\|\\"|[^"\n])*["\n]'m, Str
+        rule %r"'\\.'|'[^\\]'", Str::Char
+        rule %r"[0-9](\.[0-9]+)?([eE][+-][0-9]+)?[flFL]?|0[xX][0-9a-fA-F]+[Ll]?", Num
+        rule %r'(@#{class_name})', Name::Decorator
+        rule %r'(#{class_name})(<)' do
+          groups Name::Class, Punctuation
+          push :generic_parameters
+        end
+        rule class_name, Name::Class
+        rule %r'(#{name})(?=\s*[({])', Name::Function
+        rule %r'(#{name})@', Name::Decorator # label
+        rule name, Name
       end
 
       state :package do
-        rule /\S+/, Name::Namespace, :pop!
+        rule %r'\S+', Name::Namespace, :pop!
       end
 
       state :class do
-        rule id, Name::Class, :pop!
+        rule class_name, Name::Class, :pop!
+      end
+
+      state :function do
+        rule %r'(<)', Punctuation, :generic_parameters
+        rule %r'(\s+)', Text
+        rule %r'(#{class_name})(\.)' do
+          groups Name::Class, Punctuation
+        end
+        rule name, Name::Function, :pop!
+      end
+
+      state :generic_parameters do
+        rule class_name, Name::Class
+        rule %r'(<)', Punctuation, :generic_parameters
+        rule %r'(,)', Punctuation
+        rule %r'(\s+)', Text
+        rule %r'(>)', Punctuation, :pop!
       end
 
       state :property do
-        rule id, Name::Property, :pop!
+        rule name, Name::Property, :pop!
+      end
+
+      state :destructure do
+        rule %r'(,)', Punctuation
+        rule %r'(\))', Punctuation, :pop!
+        rule %r'(\s+)', Text
+        rule name, Name::Property
+      end
+
+      state :comment do
+        rule %r'\s*/[*].*', Comment::Multiline, :comment
+        rule %r'.*[*]/', Comment::Multiline, :pop!
+        rule %r'.*', Comment::Multiline
       end
     end
   end

data/lib/rouge/lexers/lasso.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 require 'yaml'
 
@@ -33,37 +34,32 @@ module Rouge
         push :lasso if start_inline?
       end
 
-      class << self
-        attr_reader :keywords
-      end
-
-      # Load Lasso keywords from separate YML file
-      @keywords = ::YAML.load_file(Pathname.new(__FILE__).dirname.join('lasso/keywords.yml')).tap do |h|
-        h.each do |k,v|
-          h[k] = Set.new v
-        end
+      # self-modifying method that loads the keywords file
+      def self.keywords
+        load File.join(Lexers::BASE_DIR, 'lasso/keywords.rb')
+        keywords
       end
 
       id = /[a-z_][\w.]*/i
 
       state :root do
-        rule /^#![ \S]+lasso9\b/, Comment::Preproc, :lasso
+        rule %r/^#![ \S]+lasso9\b/, Comment::Preproc, :lasso
         rule(/(?=\[|<)/) { push :delimiters }
-        rule /\s+/, Text::Whitespace
+        rule %r/\s+/, Text::Whitespace
         rule(//) { push :delimiters; push :lassofile }
       end
 
       state :delimiters do
-        rule /\[no_square_brackets\]/, Comment::Preproc, :nosquarebrackets
-        rule /\[noprocess\]/, Comment::Preproc, :noprocess
-        rule /\[/, Comment::Preproc, :squarebrackets
-        rule /<\?(lasso(script)?|=)/i, Comment::Preproc, :anglebrackets
+        rule %r/\[no_square_brackets\]/, Comment::Preproc, :nosquarebrackets
+        rule %r/\[noprocess\]/, Comment::Preproc, :noprocess
+        rule %r/\[/, Comment::Preproc, :squarebrackets
+        rule %r/<\?(lasso(script)?|=)/i, Comment::Preproc, :anglebrackets
         rule(/([^\[<]|<!--.*?-->|<(script|style).*?\2>|<(?!\?(lasso(script)?|=)))+/im) { delegate parent }
       end
 
       state :nosquarebrackets do
-        rule /\[noprocess\]/, Comment::Preproc, :noprocess
-        rule /<\?(lasso(script)?|=)/i, Comment::Preproc, :anglebrackets
+        rule %r/\[noprocess\]/, Comment::Preproc, :noprocess
+        rule %r/<\?(lasso(script)?|=)/i, Comment::Preproc, :anglebrackets
         rule(/([^\[<]|<!--.*?-->|<(script|style).*?\2>|<(?!\?(lasso(script)?|=))|\[(?!noprocess))+/im) { delegate parent }
       end
 
@@ -73,22 +69,22 @@ module Rouge
       end
 
       state :squarebrackets do
-        rule /\]/, Comment::Preproc, :pop!
+        rule %r/\]/, Comment::Preproc, :pop!
         mixin :lasso
       end
 
       state :anglebrackets do
-        rule /\?>/, Comment::Preproc, :pop!
+        rule %r/\?>/, Comment::Preproc, :pop!
         mixin :lasso
       end
 
       state :lassofile do
-        rule /\]|\?>/, Comment::Preproc, :pop!
+        rule %r/\]|\?>/, Comment::Preproc, :pop!
         mixin :lasso
       end
 
       state :whitespacecomments do
-        rule /\s+/, Text
+        rule %r/\s+/, Text
         rule %r(//.*?\n), Comment::Single
         rule %r(/\*\*!.*?\*/)m, Comment::Doc
         rule %r(/\*.*?\*/)m, Comment::Multiline
@@ -98,43 +94,43 @@ module Rouge
         mixin :whitespacecomments
 
         # literals
-        rule /\d*\.\d+(e[+-]?\d+)?/i, Num::Float
-        rule /0x[\da-f]+/i, Num::Hex
-        rule /\d+/, Num::Integer
-        rule /(infinity|NaN)\b/i, Num
-        rule /'[^'\\]*(\\.[^'\\]*)*'/m, Str::Single
-        rule /"[^"\\]*(\\.[^"\\]*)*"/m, Str::Double
-        rule /`[^`]*`/m, Str::Backtick
+        rule %r/\d*\.\d+(e[+-]?\d+)?/i, Num::Float
+        rule %r/0x[\da-f]+/i, Num::Hex
+        rule %r/\d+/, Num::Integer
+        rule %r/(infinity|NaN)\b/i, Num
+        rule %r/'[^'\\]*(\\.[^'\\]*)*'/m, Str::Single
+        rule %r/"[^"\\]*(\\.[^"\\]*)*"/m, Str::Double
+        rule %r/`[^`]*`/m, Str::Backtick
 
         # names
-        rule /\$#{id}/, Name::Variable
-        rule /#(#{id}|\d+\b)/, Name::Variable::Instance
-        rule /(\.\s*)('#{id}')/ do
+        rule %r/\$#{id}/, Name::Variable
+        rule %r/#(#{id}|\d+\b)/, Name::Variable::Instance
+        rule %r/(\.\s*)('#{id}')/ do
           groups Name::Builtin::Pseudo, Name::Variable::Class
         end
-        rule /(self)(\s*->\s*)('#{id}')/i do
+        rule %r/(self)(\s*->\s*)('#{id}')/i do
           groups Name::Builtin::Pseudo, Operator, Name::Variable::Class
         end
-        rule /(\.\.?\s*)(#{id}(=(?!=))?)/ do
+        rule %r/(\.\.?\s*)(#{id}(=(?!=))?)/ do
           groups Name::Builtin::Pseudo, Name::Other
         end
-        rule /(->\\?\s*|&\s*)(#{id}(=(?!=))?)/ do
+        rule %r/(->\\?\s*|&\s*)(#{id}(=(?!=))?)/ do
           groups Operator, Name::Other
         end
-        rule /(?<!->)(self|inherited|currentcapture|givenblock)\b/i, Name::Builtin::Pseudo
-        rule /-(?!infinity)#{id}/i, Name::Attribute
-        rule /::\s*#{id}/, Name::Label
-        rule /error_((code|msg)_\w+|adderror|columnrestriction|databaseconnectionunavailable|databasetimeout|deleteerror|fieldrestriction|filenotfound|invaliddatabase|invalidpassword|invalidusername|modulenotfound|noerror|nopermission|outofmemory|reqcolumnmissing|reqfieldmissing|requiredcolumnmissing|requiredfieldmissing|updateerror)/i, Name::Exception
+        rule %r/(?<!->)(self|inherited|currentcapture|givenblock)\b/i, Name::Builtin::Pseudo
+        rule %r/-(?!infinity)#{id}/i, Name::Attribute
+        rule %r/::\s*#{id}/, Name::Label
+        rule %r/error_((code|msg)_\w+|adderror|columnrestriction|databaseconnectionunavailable|databasetimeout|deleteerror|fieldrestriction|filenotfound|invaliddatabase|invalidpassword|invalidusername|modulenotfound|noerror|nopermission|outofmemory|reqcolumnmissing|reqfieldmissing|requiredcolumnmissing|requiredfieldmissing|updateerror)/i, Name::Exception
 
         # definitions
-        rule /(define)(\s+)(#{id})(\s*=>\s*)(type|trait|thread)\b/i do
+        rule %r/(define)(\s+)(#{id})(\s*=>\s*)(type|trait|thread)\b/i do
           groups Keyword::Declaration, Text, Name::Class, Operator, Keyword
         end
         rule %r((define)(\s+)(#{id})(\s*->\s*)(#{id}=?|[-+*/%]))i do
           groups Keyword::Declaration, Text, Name::Class, Operator, Name::Function
           push :signature
         end
-        rule /(define)(\s+)(#{id})/i do
+        rule %r/(define)(\s+)(#{id})/i do
           groups Keyword::Declaration, Text, Name::Function
           push :signature
         end
@@ -142,25 +138,25 @@ module Rouge
           groups Keyword, Text, Name::Function
           push :signature
         end
-        rule /(public|protected|private|provide)(\s+)(#{id})/i do
+        rule %r/(public|protected|private|provide)(\s+)(#{id})/i do
           groups Keyword, Text, Name::Function
         end
 
         # keywords
-        rule /(true|false|none|minimal|full|all|void)\b/i, Keyword::Constant
-        rule /(local|var|variable|global|data(?=\s))\b/i, Keyword::Declaration
-        rule /(array|date|decimal|duration|integer|map|pair|string|tag|xml|null|boolean|bytes|keyword|list|locale|queue|set|stack|staticarray)\b/i, Keyword::Type
-        rule /(#{id})(\s+)(in)\b/i do
+        rule %r/(true|false|none|minimal|full|all|void)\b/i, Keyword::Constant
+        rule %r/(local|var|variable|global|data(?=\s))\b/i, Keyword::Declaration
+        rule %r/(array|date|decimal|duration|integer|map|pair|string|tag|xml|null|boolean|bytes|keyword|list|locale|queue|set|stack|staticarray)\b/i, Keyword::Type
+        rule %r/(#{id})(\s+)(in)\b/i do
           groups Name, Text, Keyword
         end
-        rule /(let|into)(\s+)(#{id})/i do
+        rule %r/(let|into)(\s+)(#{id})/i do
           groups Keyword, Text, Name
         end
 
         # other
-        rule /,/, Punctuation, :commamember
-        rule /(and|or|not)\b/i, Operator::Word
-        rule /(#{id})(\s*::\s*#{id})?(\s*=(?!=|>))/ do
+        rule %r/,/, Punctuation, :commamember
+        rule %r/(and|or|not)\b/i, Operator::Word
+        rule %r/(#{id})(\s*::\s*#{id})?(\s*=(?!=|>))/ do
           groups Name, Name::Label, Operator
         end
 
@@ -182,31 +178,31 @@ module Rouge
           end
         end
 
-        rule /(=)(n?bw|n?ew|n?cn|lte?|gte?|n?eq|n?rx|ft)\b/i do
+        rule %r/(=)(n?bw|n?ew|n?cn|lte?|gte?|n?eq|n?rx|ft)\b/i do
           groups Operator, Operator::Word
         end
         rule %r(:=|[-+*/%=<>&|!?\\]+), Operator
-        rule /[{}():;,@^]/, Punctuation
+        rule %r/[{}():;,@^]/, Punctuation
       end
 
       state :signature do
-        rule /\=>/, Operator, :pop!
-        rule /\)/, Punctuation, :pop!
-        rule /[(,]/, Punctuation, :parameter
+        rule %r/\=>/, Operator, :pop!
+        rule %r/\)/, Punctuation, :pop!
+        rule %r/[(,]/, Punctuation, :parameter
         mixin :lasso
       end
 
       state :parameter do
-        rule /\)/, Punctuation, :pop!
-        rule /-?#{id}/, Name::Attribute, :pop!
-        rule /\.\.\./, Name::Builtin::Pseudo
+        rule %r/\)/, Punctuation, :pop!
+        rule %r/-?#{id}/, Name::Attribute, :pop!
+        rule %r/\.\.\./, Name::Builtin::Pseudo
         mixin :lasso
       end
 
       state :commamember do
         rule %r((#{id}=?|[-+*/%])(?=\s*(\(([^()]*\([^()]*\))*[^\)]*\)\s*)?(::[\w.\s]+)?=>)), Name::Function, :signature
         mixin :whitespacecomments
-        rule //, Text, :pop!
+        rule %r//, Text, :pop!
       end
 
     end

data/lib/rouge/lexers/lasso/keywords.rb

@@ -0,0 +1,14 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+# automatically generated by `rake builtins:lasso`
+module Rouge
+  module Lexers
+    def Lasso.keywords
+      @keywords ||= {}.tap do |h|
+        h[:keywords] = Set.new ["cache", "database_names", "database_schemanames", "database_tablenames", "define_tag", "define_type", "email_batch", "encode_set", "html_comment", "handle", "handle_error", "header", "if", "inline", "iterate", "ljax_target", "link", "link_currentaction", "link_currentgroup", "link_currentrecord", "link_detail", "link_firstgroup", "link_firstrecord", "link_lastgroup", "link_lastrecord", "link_nextgroup", "link_nextrecord", "link_prevgroup", "link_prevrecord", "log", "loop", "namespace_using", "output_none", "portal", "private", "protect", "records", "referer", "referrer", "repeating", "resultset", "rows", "search_args", "search_arguments", "select", "sort_args", "sort_arguments", "thread_atomic", "value_list", "while", "abort", "case", "else", "fail_if", "fail_ifnot", "fail", "if_empty", "if_false", "if_null", "if_true", "loop_abort", "loop_continue", "loop_count", "params", "params_up", "return", "return_value", "run_children", "soap_definetag", "soap_lastrequest", "soap_lastresponse", "tag_name", "ascending", "average", "by", "define", "descending", "do", "equals", "frozen", "group", "handle_failure", "import", "in", "into", "join", "let", "match", "max", "min", "on", "order", "parent", "protected", "provide", "public", "require", "returnhome", "skip", "split_thread", "sum", "take", "thread", "to", "trait", "type", "where", "with", "yield", "yieldhome"]
+        h[:types_traits] = Set.new ["atbegin", "bson_iter", "bson", "bytes_document_body", "cache_server_element", "cache_server", "capture", "client_address", "client_ip", "component_container", "component_render_state", "component", "curl", "curltoken", "currency", "custom", "data_document", "database_registry", "dateandtime", "dbgp_packet", "dbgp_server", "debugging_stack", "delve", "dir", "dirdesc", "dns_response", "document_base", "document_body", "document_header", "dsinfo", "eacher", "email_compose", "email_parse", "email_pop", "email_queue_impl_base", "email_queue_impl", "email_smtp", "email_stage_impl_base", "email_stage_impl", "fastcgi_each_fcgi_param", "fastcgi_server", "fcgi_record", "fcgi_request", "file", "filedesc", "filemaker_datasource", "generateforeachkeyed", "generateforeachunkeyed", "generateseries", "hash_map", "html_atomic_element", "html_attr", "html_base", "html_binary", "html_br", "html_cdata", "html_container_element", "html_div", "html_document_body", "html_document_head", "html_eol", "html_fieldset", "html_form", "html_h1", "html_h2", "html_h3", "html_h4", "html_h5", "html_h6", "html_hr", "html_img", "html_input", "html_json", "html_label", "html_legend", "html_link", "html_meta", "html_object", "html_option", "html_raw", "html_script", "html_select", "html_span", "html_style", "html_table", "html_td", "html_text", "html_th", "html_tr", "http_document_header", "http_document", "http_error", "http_header_field", "http_server_connection_handler_globals", "http_server_connection_handler", "http_server_request_logger_thread", "http_server_web_connection", "http_server", "image", "include_cache", "inline_type", "java_jnienv", "jbyte", "jbytearray", "jchar", "jchararray", "jfieldid", "jfloat", "jint", "jmethodid", "jobject", "jshort", "json_decode", "json_encode", "json_literal", "json_object", "lassoapp_compiledsrc_appsource", "lassoapp_compiledsrc_fileresource", "lassoapp_content_rep_halt", "lassoapp_dirsrc_appsource", "lassoapp_dirsrc_fileresource", "lassoapp_installer", "lassoapp_livesrc_appsource", "lassoapp_livesrc_fileresource", "lassoapp_long_expiring_bytes", "lassoapp_manualsrc_appsource", "lassoapp_zip_file_server", "lassoapp_zipsrc_appsource", "lassoapp_zipsrc_fileresource", "ldap", "library_thread_loader", "list_node", "log_impl_base", "log_impl", "magick_image", "map_node", "memberstream", "memory_session_driver_impl_entry", "memory_session_driver_impl", "memory_session_driver", "mime_reader", "mongo_client", "mongo_collection", "mongo_cursor", "mustache_ctx", "mysql_session_driver_impl", "mysql_session_driver", "net_named_pipe", "net_tcp_ssl", "net_tcp", "net_udp_packet", "net_udp", "odbc_session_driver_impl", "odbc_session_driver", "opaque", "os_process", "pair_compare", "pairup", "pdf_barcode", "pdf_chunk", "pdf_color", "pdf_doc", "pdf_font", "pdf_hyphenator", "pdf_image", "pdf_list", "pdf_paragraph", "pdf_phrase", "pdf_read", "pdf_table", "pdf_text", "pdf_typebase", "percent", "portal_impl", "queriable_groupby", "queriable_grouping", "queriable_groupjoin", "queriable_join", "queriable_orderby", "queriable_orderbydescending", "queriable_select", "queriable_selectmany", "queriable_skip", "queriable_take", "queriable_thenby", "queriable_thenbydescending", "queriable_where", "raw_document_body", "regexp", "repeat", "scientific", "security_registry", "serialization_element", "serialization_object_identity_compare", "serialization_reader", "serialization_writer_ref", "serialization_writer_standin", "serialization_writer", "session_delete_expired_thread", "signature", "sourcefile", "sqlite_column", "sqlite_currentrow", "sqlite_db", "sqlite_results", "sqlite_session_driver_impl_entry", "sqlite_session_driver_impl", "sqlite_session_driver", "sqlite_table", "sqlite3_stmt", "sqlite3", "sys_process", "text_document", "tie", "timeonly", "tree_base", "tree_node", "tree_nullnode", "ucal", "usgcpu", "usgvm", "web_error_atend", "web_node_base", "web_node_content_representation_css_specialized", "web_node_content_representation_html_specialized", "web_node_content_representation_js_specialized", "web_node_content_representation_xhr_container", "web_node_echo", "web_node_root", "web_request_impl", "web_request", "web_response_impl", "web_response", "web_router", "websocket_handler", "worker_pool", "xml_attr", "xml_cdatasection", "xml_characterdata", "xml_comment", "xml_document", "xml_documentfragment", "xml_documenttype", "xml_domimplementation", "xml_element", "xml_entity", "xml_entityreference", "xml_namednodemap_attr", "xml_namednodemap_ht", "xml_namednodemap", "xml_node", "xml_nodelist", "xml_notation", "xml_processinginstruction", "xml_text", "xmlstream", "zip_file_impl", "zip_file", "zip_impl", "zip", "any", "formattingbase", "html_attributed", "html_element_coreattrs", "html_element_eventsattrs", "html_element_i18nattrs", "lassoapp_capabilities", "lassoapp_resource", "lassoapp_source", "queriable_asstring", "session_driver", "trait_array", "trait_asstring", "trait_backcontractible", "trait_backended", "trait_backexpandable", "trait_close", "trait_contractible", "trait_decompose_assignment", "trait_doubleended", "trait_each_sub", "trait_encodeurl", "trait_endedfullymutable", "trait_expandable", "trait_file", "trait_finite", "trait_finiteforeach", "trait_foreach", "trait_foreachtextelement", "trait_frontcontractible", "trait_frontended", "trait_frontexpandable", "trait_fullymutable", "trait_generator", "trait_generatorcentric", "trait_hashable", "trait_json_serialize", "trait_keyed", "trait_keyedfinite", "trait_keyedforeach", "trait_keyedmutable", "trait_list", "trait_map", "trait_net", "trait_pathcomponents", "trait_positionallykeyed", "trait_positionallysearchable", "trait_queriable", "trait_queriablelambda", "trait_readbytes", "trait_readstring", "trait_scalar", "trait_searchable", "trait_serializable", "trait_setencoding", "trait_setoperations", "trait_stack", "trait_treenode", "trait_writebytes", "trait_writestring", "trait_xml_elementcompat", "trait_xml_nodecompat", "web_connection", "web_node_container", "web_node_content_css_specialized", "web_node_content_document", "web_node_content_html_specialized", "web_node_content_js_specialized", "web_node_content_json_specialized", "web_node_content_representation", "web_node_content", "web_node_postable", "web_node"]
+      end
+    end
+  end
+end

data/lib/rouge/lexers/liquid.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers
@@ -9,191 +10,177 @@ module Rouge
       filenames '*.liquid'
 
       state :root do
-        rule /[^\{]+/, Text
+        rule %r/[^\{]+/, Text
 
-        rule /(\{%)(\s*)/ do
+        rule %r/(\{%-?)(\s*)/ do
           groups Punctuation, Text::Whitespace
           push :tag_or_block
         end
 
-        rule /(\{\{)(\s*)/ do
+        rule %r/(\{\{-?)(\s*)/ do
           groups Punctuation, Text::Whitespace
           push :output
         end
 
-        rule /\{/, Text
+        rule %r/\{/, Text
       end
 
       state :tag_or_block do
         # builtin logic blocks
-        rule /(if|unless|elsif|case)(?=\s+)/, Keyword::Reserved, :condition
+        rule %r/(if|elsif|unless|case)\b/, Keyword::Reserved, :condition
+        rule %r/(when)\b/, Keyword::Reserved, :when
 
-        rule /(when)(\s+)/ do
-          groups Keyword::Reserved, Text::Whitespace
-          push :when
-        end
-
-        rule /(else)(\s*)(%\})/ do
+        rule %r/(else)(\s*)(-?%\})/ do
           groups Keyword::Reserved, Text::Whitespace, Punctuation
           pop!
         end
 
         # other builtin blocks
-        rule /(capture)(\s+)([^\s%]+)(\s*)(%\})/ do
-          groups Name::Tag, Text::Whitespace, Name::Attribute, Text::Whitespace, Punctuation
+        rule %r/(capture|(?:in|de)crement)(\s+)([^\s%]+)(\s*)(-?%\})/ do
+          groups Name::Tag, Text::Whitespace, Name::Variable, Text::Whitespace, Punctuation
           pop!
         end
 
-        rule /(comment)(\s*)(%\})/ do
+        rule %r/(comment)(\s*)(-?%\})/ do
           groups Name::Tag, Text::Whitespace, Punctuation
           push :comment
         end
 
-        rule /(raw)(\s*)(%\})/ do
+        rule %r/(raw)(\s*)(-?%\})/ do
           groups Name::Tag, Text::Whitespace, Punctuation
           push :raw
         end
 
-        rule /assign/, Name::Tag, :assign
-        rule /include/, Name::Tag, :include
-
         # end of block
-        rule /(end(case|unless|if))(\s*)(%\})/ do
-          groups Keyword::Reserved, nil, Text::Whitespace, Punctuation
+        rule %r/(end(?:if|unless|case))(\s*)(-?%\})/ do
+          groups Keyword::Reserved, Text::Whitespace, Punctuation
           pop!
         end
 
-        rule /(end([^\s%]+))(\s*)(%\})/ do
-          groups Name::Tag, nil, Text::Whitespace, Punctuation
+        rule %r/(end(?:[^\s%]+))(\s*)(-?%\})/ do
+          groups Name::Tag, Text::Whitespace, Punctuation
           pop!
         end
 
         # builtin tags
-        rule /(cycle)(\s+)(([^\s:]*)(:))?(\s*)/ do |m|
-          token Name::Tag, m[1]
-          token Text::Whitespace, m[2]
+        rule %r/(assign|echo)\b/, Name::Tag, :assign
+        rule %r/(include|render)\b/, Name::Tag, :include
 
-          if m[4] =~ /'[^']*'/
-            token Str::Single, m[4]
-          elsif m[4] =~ /"[^"]*"/
-            token Str::Double, m[4]
-          else
-            token Name::Attribute, m[4]
-          end
+        rule %r/(cycle)(\s+)(?:([^\s:]*)(\s*)(:))?(\s*)/ do |m|
+          token_class = case m[3]
+                        when %r/'[^']*'/ then Str::Single
+                        when %r/"[^"]*"/ then Str::Double
+                        else
+                          Name::Attribute
+                        end
 
-          token Punctuation, m[5]
-          token Text::Whitespace, m[6]
+          groups Name::Tag, Text::Whitespace, token_class,
+                 Text::Whitespace, Punctuation, Text::Whitespace
 
           push :variable_tag_markup
         end
 
+        # iteration
+        rule %r/
+          (for|tablerow)(\s+)
+          ([\w-]+)(\s+)
+          (in)(\s+)
+          (
+            (?: [^\s%,\|'"] | (?:"[^"]*"|'[^']*') )+
+          )(\s*)
+        /x do |m|
+          groups Name::Tag, Text::Whitespace, Name::Variable, Text::Whitespace,
+                 Name::Tag, Text::Whitespace
+
+          token_class = case m[7]
+                        when %r/'[^']*'/ then Str::Single
+                        when %r/"[^"]*"/ then Str::Double
+                        else
+                          Name::Variable
+                        end
+          token token_class, m[7]
+          token Text::Whitespace, m[8]
+          push :tag_markup
+        end
+
         # other tags or blocks
-        rule /([^\s%]+)(\s*)/ do
+        rule %r/([^\s%]+)(\s*)/ do
           groups Name::Tag, Text::Whitespace
           push :tag_markup
         end
       end
 
       state :output do
-        mixin :whitespace
-        mixin :generic
+        rule %r/(\|)(\s*)([a-zA-Z_][^\s}\|:]*)/ do
+          groups Punctuation, Text::Whitespace, Name::Function
+          push :filters
+        end
 
-        rule /\}\}/, Punctuation, :pop!
-        rule /\|/, Punctuation, :filters
+        mixin :end_of_tag
+        mixin :generic
       end
 
       state :filters do
-        mixin :whitespace
-
-        rule(/\}\}/) { token Punctuation; reset_stack }
-
-        rule /([^\s\|:]+)(:?)(\s*)/ do
-          groups Name::Function, Punctuation, Text::Whitespace
-          push :filter_markup
+        rule %r/(\|)(\s*)([a-zA-Z_][^\s%}\|:]*)/ do
+          groups Punctuation, Text::Whitespace, Name::Function
         end
-      end
-
-      state :filter_markup do
-        rule /\|/, Punctuation, :pop!
 
         mixin :end_of_tag
         mixin :end_of_block
-        mixin :default_param_markup
+        mixin :variable_param_markup
       end
 
       state :condition do
-        mixin :end_of_block
-        mixin :whitespace
-
-        rule /([=!><]=?)/, Operator
-
-        rule /\b((!)|(not\b))/ do
-          groups nil, Operator, Operator::Word
-        end
-
-        rule /(contains)/, Operator::Word
+        rule %r/([=!]=|[<>]=?)/, Operator
+        rule %r/(and|or|contains)\b/, Operator::Word
 
+        mixin :end_of_block
         mixin :generic
-        mixin :whitespace
       end
 
       state :when do
         mixin :end_of_block
-        mixin :whitespace
         mixin :generic
       end
 
-      state :operator do
-        rule /(\s*)((=|!|>|<)=?)(\s*)/ do
-          groups Text::Whitespace, Operator, nil, Text::Whitespace
-          pop!
-        end
-
-        rule /(\s*)(\bcontains\b)(\s*)/ do
-          groups Text::Whitespace, Operator::Word, Text::Whitespace
-          pop!
-        end
-      end
-
       state :end_of_tag do
-        rule(/\}\}/) { token Punctuation; reset_stack }
+        rule(/-?\}\}/) { token Punctuation; reset_stack }
       end
 
       state :end_of_block do
-        rule(/%\}/) { token Punctuation; reset_stack }
+        rule(/-?%\}/) { token Punctuation; reset_stack }
       end
 
       # states for unknown markup
       state :param_markup do
         mixin :whitespace
+        mixin :keyword
         mixin :string
+        mixin :number
 
-        rule /([^\s=:]+)(\s*)(=|:)/ do
+        rule %r/([^\s=:]+)(\s*)(=|:)/ do
           groups Name::Attribute, Text::Whitespace, Operator
         end
 
-        rule /(\{\{)(\s*)([^\s\}])(\s*)(\}\})/ do
-          groups Punctuation, Text::Whitespace, nil, Text::Whitespace, Punctuation
-        end
-
-        mixin :number
-        mixin :keyword
-
-        rule /,/, Punctuation
+        rule %r/[,:]/, Punctuation
       end
 
       state :default_param_markup do
         mixin :param_markup
-        rule /./, Text
+
+        rule %r/\S+/, Text
       end
 
       state :variable_param_markup do
         mixin :param_markup
         mixin :variable
-        rule /./, Text
+
+        rule %r/\S+/, Text
       end
 
       state :tag_markup do
+        rule %r/(reversed)\b/, Name::Attribute
+
         mixin :end_of_block
         mixin :default_param_markup
       end
@@ -205,83 +192,94 @@ module Rouge
 
       # states for different values types
       state :keyword do
-        rule /\b(false|true)\b/, Keyword::Constant
+        rule %r/(false|true|nil)\b/, Keyword::Constant
       end
 
       state :variable do
-        rule /\.(?=\w)/, Punctuation
-        rule /[a-zA-Z_]\w*\??/, Name::Variable
+        rule %r/(empty|blank|forloop\.[^\s%}\|:]+)\b/, Name::Builtin
+        rule %r/\.(?=\w)|\[|\]/, Punctuation
+        rule %r/(first|last|size)\b/, Name::Function
+        rule %r/[a-zA-Z_][\w-]*\??/, Name::Variable
       end
 
       state :string do
-        rule /'[^']*'/, Str::Single
-        rule /"[^"]*"/, Str::Double
+        rule %r/'[^']*'/, Str::Single
+        rule %r/"[^"]*"/, Str::Double
       end
 
       state :number do
-        rule /\d+\.\d+/, Num::Float
-        rule /\d+/, Num::Integer
-      end
-
-      state :array_index do
-        rule /\[/, Punctuation
-        rule /\]/, Punctuation
+        rule %r/-/, Operator
+        rule %r/\d+\.\d+/, Num::Float
+        rule %r/\d+/, Num::Integer
       end
 
       state :generic do
-        mixin :array_index
+        mixin :whitespace
         mixin :keyword
         mixin :string
-        mixin :variable
         mixin :number
+        mixin :variable
       end
 
       state :whitespace do
-        rule /[ \t]+/, Text::Whitespace
+        rule %r/[ \t]+/, Text::Whitespace
       end
 
       state :comment do
-        rule /(\{%)(\s*)(endcomment)(\s*)(%\})/ do
+        rule %r/[^\{]+/, Comment
+
+        rule %r/(\{%-?)(\s*)(endcomment)(\s*)(-?%\})/ do
           groups Punctuation, Text::Whitespace, Name::Tag, Text::Whitespace, Punctuation
           reset_stack
         end
 
-        rule /./, Comment
+        rule %r/\{/, Comment
       end
 
       state :raw do
-        rule /[^\{]+/, Text
+        rule %r/[^\{]+/, Text
 
-        rule /(\{%)(\s*)(endraw)(\s*)(%\})/ do
+        rule %r/(\{%-?)(\s*)(endraw)(\s*)(-?%\})/ do
           groups Punctuation, Text::Whitespace, Name::Tag, Text::Whitespace, Punctuation
           reset_stack
         end
 
-        rule /\{/, Text
+        rule %r/\{/, Text
       end
 
       state :assign do
-        mixin :whitespace
-        mixin :end_of_block
+        rule %r/=/, Operator
 
-        rule /(\s*)(=)(\s*)/ do
-          groups Text::Whitespace, Operator, Text::Whitespace
+        rule %r/(\|)(\s*)([a-zA-Z_][^\s%\|:]*)/ do
+          groups Punctuation, Text::Whitespace, Name::Function
+          push :filters
         end
 
-        rule /\|/, Punctuation, :filters
-
+        mixin :end_of_block
         mixin :generic
       end
 
       state :include do
-        mixin :whitespace
-
-        rule /([^\.]+)(\.)(html|liquid)/ do
-          groups Name::Attribute, Punctuation, Name::Attribute
+        rule %r/(\{\{-?)(\s*)/ do
+          groups Punctuation, Text::Whitespace
+          push :output_embed
         end
 
+        rule %r/(with|for)\b/, Name::Tag
+        rule %r/[\/\w-]+(\.[\w-]+)+\b/, Text
+
         mixin :variable_tag_markup
       end
+
+      state :output_embed do
+        rule %r/(\|)(\s*)([a-zA-Z_][^\s}\|:]*)/ do
+          groups Punctuation, Text::Whitespace, Name::Function
+        end
+
+        rule %r/-?\}\}/, Punctuation, :pop!
+
+        mixin :variable_param_markup
+      end
     end
   end
 end