CodeMirror nginx-renewed mode

This is a CodeMirror mode that brings syntax highlighting for nginx configuration files.

Features:

recognize more than 870 nginx directives, including those from OpenResty and nginx-plus;
unrecognized directives remain accepted (they are shown in italic)
highlight directives that are recognized but should not occur in the current scope;
highlight regular expressions -- requires codemirror-mode-pcre
supported in: locations, maps, if conditions, rewrite statements and some proxy_* directives
highlight variables in strings -- requires codemirror-mode-variables;
highlight IP addresses -- requires codemirror-mode-ipaddr;
supported in: geo, set_real_ip_from
highlight Lua code -- requires CodeMirror's Lua mode; without it, strings and comments are still highlighted;
supported in: blocks (*_by_lua_block)
not supported in: strings (*_by_lua)

MIME types defined:

text/x-nginx-conf

Options:

initial_scope: string; default value: "main"
check_directive_scope: boolean; default value: true

MIME types used to invoke nested modes:

text/x-regex
text/x-variables
text/x-ip-address
text/x-lua

Direct use

By default, codemirror-mode-nginx-renewed:

assumes the textarea reflects nginx's main scope (i.e. the same scope as nginx.conf);
checks whether each directive is allowed in the current scope.

The textareas below showcase codemirror-mode-nginx-renewed's capabilities.

Useful commands:

Ctrl+d: toggle comments
Ctrl+]: indent
Ctrl+[: unindent
Tab: auto-indent the current line or selection
Shift+Tab: if something is selected, indent it by one indent unit; otherwise, insert a tab character

user       www www;
worker_processes  5;
error_log  logs/error.log;
pid        logs/nginx.pid;
worker_rlimit_nofile 8192;

events {
	worker_connections  4096;  ## Default: 1024
}

http {
	types {
		text/html                             html htm shtml;
		text/xml                              xml rss;
		image/gif                             gif;
	}

map "${http_user_agent}" $mobile {
		default "${http_user_agent}";
		hostnames;
		volatile;
		"Opera Mini" 1;
		"~(?:Opera Mini)" 1;
		"~*(?:Opera Mini)" 1;
		include "/path/to/map/file.conf";
	}

geo $country {
		default        ZZ;
		include        conf/geo.conf;
		delete         127.0.0.0/16;
		proxy          192.168.100.0/24;
		proxy          2001:0db8::/32;

127.0.0.0/24   US;
		127.0.0.1/32   RU;
		10.1.0.0/16    RU;
		192.168.1.0/24 UK;
		1.2.3.4        TEST;
		2001:0db8::    TEST;
		2001:0db8::/32 TEST;
	}

geo $dummy_range {
		ranges;
		1.2.3.4-1.2.3.6    "IPv4 range";
		# nginx's IP ranges are IPv4-only; IPv6 ranges yield "[emerg] invalid network"
		2001:0db8::-2001:0db8:ffff:ffff:ffff:ffff:ffff:ffff "IPv6 range";
	}

set_real_ip_from 10.20.30.40;
	set_real_ip_from 10.20.30.0/24;
	set_real_ip_from 2001:0db8::1234;
	set_real_ip_from 2001:0db8::/64;
	set_real_ip_from trustme.company.com;
	real_ip_header X-Forwarded-For;
	real_ip_recursive on;

upstream bunch_of_servers {
		server server00001:80 resolve;
		server server00002:80 resolve;
		server server00003:80 resolve;
		server server00004:80 resolve;
		server server00005:80 resolve;
	}

server {
		server_name "nginx.syntax-highlighting.demo.example";
		server_name "~^nginx[^.]+\.syntax-highlighting\.demo\.example$";
		# Examples from http://nginx.org/en/docs/http/server_names.html:
		server_name example.org  www.example.org;
		server_name *.example.org;
		server_name mail.*;
		server_name ~^(?<user>.+)\.example\.net$;
		server_name ~^www\d+\.example\.net$;
		server_name "~^(?<name>\w+\d{1,3})\.example\.net$";
		server_name ~^(www\.)?(?<domain>.+)$;
		server_name ~^(www\.)?(.+)$;
		server_name example.org  www.example.org  "";

# Locations, using double-quotes, single-quotes and unquoted strings:
		location  =  "/exact-match" {}         location  =  '/exact-match' {}         location  =  /exact-match {}
		location     "/prefix-match-wi-re" {}  location     '/prefix-match-wi-re' {}  location     /prefix-match-wi-re {}
		location ^~  "/prefix-match-wo-re" {}  location ^~  '/prefix-match-wo-re' {}  location ^~  /prefix-match-wo-re {}
		location  ~  "(cs|regex|match)" {}     location  ~  '(cs|regex|match)' {}     location  ~  (cs|regex|match) {}
		location  ~* "(ci|regex|match)" {}     location  ~* '(ci|regex|match)' {}     location  ~* (ci|regex|match) {}

# Conditions, using double-quotes, single-quotes and unquoted strings:
		if ($variable  =  "${text}/x-variables") {}  if ($variable  =  '${text}/x-variables') {}  if ($variable  =  ${text}/x-variables) {}
		if ($variable !=  "${text}/x-variables") {}  if ($variable !=  '${text}/x-variables') {}  if ($variable !=  ${text}/x-variables) {}
		if ($variable  ~  "^text/(?x:-[regex])") {}  if ($variable  ~  '^text/(?x:-[regex])') {}  if ($variable  ~  ^text/(?x:-[regex])) {}
		if ($variable  ~* "^text/(?x:-[regex])") {}  if ($variable  ~* '^text/(?x:-[regex])') {}  if ($variable  ~* ^text/(?x:-[regex])) {}
		if ($variable !~  "^text/(?x:-[regex])") {}  if ($variable !~  '^text/(?x:-[regex])') {}  if ($variable !~  ^text/(?x:-[regex])) {}
		if ($variable !~* "^text/(?x:-[regex])") {}  if ($variable !~* '^text/(?x:-[regex])') {}  if ($variable !~* ^text/(?x:-[regex])) {}
		if ( -f "${text}/x-variables") {}            if ( -f '${text}/x-variables') {}            if ( -f ${text}/x-variables) {}
		if (!-f "${text}/x-variables") {}            if (!-f '${text}/x-variables') {}            if (!-f ${text}/x-variables) {}
		if ( -d "${text}/x-variables") {}            if ( -d '${text}/x-variables') {}            if ( -d ${text}/x-variables) {}
		if (!-d "${text}/x-variables") {}            if (!-d '${text}/x-variables') {}            if (!-d ${text}/x-variables) {}
		if ( -e "${text}/x-variables") {}            if ( -e '${text}/x-variables') {}            if ( -e ${text}/x-variables) {}
		if (!-e "${text}/x-variables") {}            if (!-e '${text}/x-variables') {}            if (!-e ${text}/x-variables) {}
		if ( -x "${text}/x-variables") {}            if ( -x '${text}/x-variables') {}            if ( -x ${text}/x-variables) {}
		if (!-x "${text}/x-variables") {}            if (!-x '${text}/x-variables') {}            if (!-x ${text}/x-variables) {}
		# without forgetting the simplest case:
		if ($variable) {}

# Unquoted strings in conditions:
		if (                                    # condition comment
			$variable !~* ^text/(?x:-[regex])   # condition comment
		)                                       # condition comment
		# post-condition, pre-scope comment
		{   # scope comment
			# scope comment
		}   # post-scope comment

# Rewrites:
		rewrite "^/foo(?<tail>.*)" "/bar${tail}";
		rewrite '^/foo(?<tail>.*)' '/bar${tail}' break;
		rewrite  ^/foo(?<tail>.*)   /bar${tail}  last;

# Other mod_rewrite directives:
		rewrite_log on;
		uninitialized_variable_warn off;
		break;

location / {
			limit_except GET PROPFIND LOCK {
				deny all;
			}
			proxy_pass http://bunch_of_servers;

proxy_redirect off;
			proxy_redirect default;
			proxy_redirect http://$proxy_host:8000/ /;
			proxy_redirect ~^(http://[^:]+):\d+(/.+)$ $1$2;
			proxy_redirect ~*/user/([^/]+)/(.+)$      http://$1.example.com/$2;

location /foo {
				proxy_cookie_domain off;
				proxy_cookie_domain localhost example.org;
				proxy_cookie_domain www.$host $host;
				proxy_cookie_domain "~\.(?<domain_and_tld>[a-z]+\.[a-z]+)$" "${domain_and_tld}";

location /foo/bar {
					proxy_cookie_path off;
					proxy_cookie_path /two/ /;
					proxy_cookie_path $uri "/some${uri}";
					proxy_cookie_path "~*^/user/(?<username>[^/]+)" "/u/${username}";

location /foo/bar/baz {
						proxy_cookie_flags off;
						proxy_cookie_flags one httponly;
						proxy_cookie_flags ${my_cookie} nohttponly;
						proxy_cookie_flags ${app_name}_session secure "samesite=${my_map}" httponly;
						proxy_cookie_flags ~^(?i:alpha_cookie|cookie_beta)$ nosecure samesite=strict;
					}
				}
			}
		}

# Enforce HTTPS for domain.tld subdomains:
		set $scheme_and_domain "${map_real_scheme}://${host}";
		if ($scheme_and_domain ~ "^http://.*\.domain\.tld\.?$") {
			return 308 "https://${host}${request_uri}";
		}
		location /redirect { return "https://somewhere.else/"; }
		location /close { return 444; }
		location /prefix {
			root /path/to/document/root/;
		}
		location ~ "(?x) # Enable PCRE extended mode
			^
			/user
			/(?<action>login|logout|profile) # Also include 'profile' because...
			/(?<tail>.*)
		"
		{
			if ($tail ~ "^(some|[^/]+/really|compl(?:ex|icated)|stuff|t?here)$") {
				return 307 "${scheme}://${host}/somewhere/else/${tail}${is_args}${args}";
			}
			# ...
		}
	}
}

This textarea is a copy of lua-nginx-module's synopsis:

# set search paths for pure Lua external libraries (';;' is the default path):
lua_package_path '/foo/bar/?.lua;/blah/?.lua;;';

# set search paths for Lua external libraries written in C (can also use ';;'):
lua_package_cpath '/bar/baz/?.so;/blah/blah/?.so;;';

server {
	location /lua_content {
		# MIME type determined by default_type:
		default_type 'text/plain';

content_by_lua_block {
			ngx.say('Hello,world!')
		}
	}

location /nginx_var {
		# MIME type determined by default_type:
		default_type 'text/plain';

# try access /nginx_var?a=hello,world
		content_by_lua_block {
			ngx.say(ngx.var.arg_a)
		}
	}

location = /request_body {
		client_max_body_size 50k;
		client_body_buffer_size 50k;

content_by_lua_block {
			ngx.req.read_body()  -- explicitly read the req body
			local data = ngx.req.get_body_data()
			if data then
				ngx.say("body data:")
				ngx.print(data)
				return
			end

-- body may get buffered in a temp file:
			local file = ngx.req.get_body_file()
			if file then
				ngx.say("body is in file ", file)
			else
				ngx.say("no body found")
			end
		}
	}

# transparent non-blocking I/O in Lua via subrequests
	# (well, a better way is to use cosockets)
	location = /lua {
		# MIME type determined by default_type:
		default_type 'text/plain';

content_by_lua_block {
			local res = ngx.location.capture("/some_other_location")
			if res then
				ngx.say("status: ", res.status)
				ngx.say("body:")
				ngx.print(res.body)
			end
		}
	}

location = /foo {
		rewrite_by_lua_block {
			res = ngx.location.capture("/memc",
				{ args = { cmd = "incr", key = ngx.var.uri } }
			)
		}

proxy_pass http://blah.blah.com;
	}

location = /mixed {
		rewrite_by_lua_file /path/to/rewrite.lua;
		access_by_lua_file /path/to/access.lua;
		content_by_lua_file /path/to/content.lua;
	}

# use nginx var in code path
	# CAUTION: contents in nginx var must be carefully filtered,
	# otherwise there'll be great security risk!
	location ~ ^/app/([-_a-zA-Z0-9/]+) {
		set $path $1;
		content_by_lua_file /path/to/lua/app/root/$path.lua;
	}

location / {
		client_max_body_size 100k;
		client_body_buffer_size 100k;

access_by_lua_block {
			-- check the client IP address is in our black list
			if ngx.var.remote_addr == "132.5.72.3" then
				ngx.exit(ngx.HTTP_FORBIDDEN)
			end

-- check if the URI contains bad words
			if ngx.var.uri and
				string.match(ngx.var.request_body, "evil")
				-- Alteration to test double square bracket strings:
				page = [==[
<HTML>
<HEAD>
<TITLE>An HTML Page</TITLE>
</HEAD>
<BODY>
<A HREF="http://www.lua.org">Lua</A>
[[a text between double brackets]]
</BODY>
</HTML>]==]
			then
				return ngx.redirect("/terms_of_use.html")
			end

-- tests passed
		}

# proxy_pass/fastcgi_pass/etc settings
	}
}

Custom use without a specific scope

Sometimes, it is hard, if not impossible, to predict the scope of an nginx snippet. Typical cases:

include files, which may contain directives suited for various scopes;
the output of "nginx -T", which may combine many files and thus many scopes.

To deal with these situations, state "check_directive_scope: false" when configuring codemirror-mode-nginx-renewed.

Custom use with specific scopes

By playing with the "initial_scope" setting, it is possible to change the nginx scope of the textarea. initial_scope defaults to "main" and can take various values reflecting the desired scope. Examples:

main/events
main/http/server/location/limit_except
main/http/server/location/if
main/http/server/location/types
main/http/server/if
main/mail/server
main/stream/upstream

CodeMirror nginx-renewed mode

Direct use

Custom use without a specific scope

Custom use with specific scopes

main/http/map

main/http/geo

main/http/types

main/http/server

main/http/server/location

main/http/upstream