junoser 0.5.2 → 0.5.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aab5884056a5ff176a5daffacb2a000a70dc9108026fcd38aef0d0f761cf17d0
-  data.tar.gz: cf10c3ccc516c51cc829b16273daf0cab69829e3ec65d48f3c3df8bef372ad2b
+  metadata.gz: 4241a7b2a24ab7118dae491d2538107fdfa0b4a0f8f4fe701e713a00197a424c
+  data.tar.gz: fba378b8cf21dc3ffc554c20ad6b0650844546b54defbe6f1fec15cea6294182
 SHA512:
-  metadata.gz: 9fd221d5bc56a46b6db96a46f32cdd88da4aef3fab73e9ede294a1c2c53ba3a2b1c9bcd88df84453faec84ab36f6990d7a4017cc13c484034b191e53d75d4b4b
-  data.tar.gz: cee62b7fda182dcf3b67e3b3b14207cd105074b89edf699a9ae455009ee843d8d8d6802e5e383dc6e07439dbf30a01e24051ac87102b07fcbadecc3978ee89b4
+  metadata.gz: 3283f8dfa5972d2ca4bdd25abc0b6c30d9b41266afb6a4ac31b6e9144c46b1adc1e4d03af939fb0ebce2a2e42b57197acaaf38c81005ffe7b1b66df75e42bef0
+  data.tar.gz: a626b7bd44f66b3cc9606a23a4342b5101deedd75f8df70eac66afa87d695971bb598a9546a50d83fea4115a9974cd23c78381a0a76e337d914facab8a8c3ebd

data/.github/workflows/test-linux.yaml

@@ -9,7 +9,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby-version: ['3.1', '3.0', '2.7']
+        ruby-version: ['3.2', '3.1', '3.0']
         os: [ubuntu-latest]
         experimental: [false]
         include:

data/CHANGELOG.md

@@ -1,20 +1,30 @@
+## [0.5.3] - 2023-07-10
+
+### Added
+
+* Newly supported syntax
+  * "chassis cluster" (by porting the hierarchy from vSRX 18.3R1.9)
+  * "security log stream xxx transport"
+
+
 ## [0.5.2] - 2022-12-10
 
 ### Fixed
 
-* "system services ssh root-login deny-password"
+* "system services ssh root-login deny-password" was unexpectedly marked as invalid
 
 
 ## [0.5.1] - 2022-11-02
 
 ### Added
 
-* Support "protocols iccp peer xxx liveness-detection single-hop"
+* Newly supported syntax
+  * "protocols iccp peer xxx liveness-detection single-hop"
+  * "poe" based on EX 18.1R3-S6.1
 
 ### Fixed
 
-* Support one-line form of "poe interface xxx" and "poe fpc xxx"
-* "interfaces xxx ether-options speed"
+* "interfaces xxx ether-options speed" was unexpectedly marked as invalid
 
 
 ## [0.5.0] - 2022-11-02

data/Gemfile.lock

@@ -1,21 +1,21 @@
 PATH
   remote: .
   specs:
-    junoser (0.5.2)
+    junoser (0.5.3)
       parslet
 
 GEM
   remote: https://rubygems.org/
   specs:
-    mini_portile2 (2.8.0)
-    nokogiri (1.13.10)
-      mini_portile2 (~> 2.8.0)
+    mini_portile2 (2.8.2)
+    nokogiri (1.15.3)
+      mini_portile2 (~> 2.8.2)
       racc (~> 1.4)
     parslet (2.0.0)
-    power_assert (2.0.2)
-    racc (1.6.1)
+    power_assert (2.0.3)
+    racc (1.7.1)
     rake (13.0.6)
-    test-unit (3.5.5)
+    test-unit (3.6.1)
       power_assert
 
 PLATFORMS
@@ -29,4 +29,4 @@ DEPENDENCIES
   test-unit
 
 BUNDLED WITH
-   2.3.24
+   2.4.1

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2015-2022 Shintaro Kojima
+Copyright (c) 2015-2023 Shintaro Kojima
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -103,4 +103,4 @@ Or send a pull request to fix.
 
 ## Copyright and License
 
-Copyright (c) 2015-2022 Shintaro Kojima. Code released under the [MIT license](LICENSE.txt).
+Copyright (c) 2015-2023 Shintaro Kojima. Code released under the [MIT license](LICENSE.txt).

data/lib/junoser/js_ruler.rb

@@ -17,23 +17,22 @@ module Junoser
     def rule
       str = @rule.read
       str = process_lines(str)
-      str = str.split(/\n/).map {|l|
-        process_line(l) unless l =~ /^ *#/  # Skip additional comment lines
+      str = str.split(/\n/).map { |l|
+        process_line(l) unless l =~ /^ *#/ # Skip additional comment lines
       }.compact.join("\n")
       finalize(str)
     end
 
-
     private
 
     def process_line(str)
-      remove_undefined_variables(str)
-      process_common_syntax(str)
-      process_argument_syntax(str)
-      process_structural_syntax(str)
-      process_word(str)
-      process_reserved_word(str)
-      process_comment(str)
+      str = remove_undefined_variables(str)
+      str = process_common_syntax(str)
+      str = process_argument_syntax(str)
+      str = process_structural_syntax(str)
+      str = process_word(str)
+      str = process_reserved_word(str)
+      str = process_comment(str)
 
       str
     end
@@ -49,31 +48,31 @@ module Junoser
 
     def process_common_syntax(str)
       # rule(:foo) do  ->  foo(...args) {
-      str.gsub!(/^rule\(:(\S+)\) do/) {"#$1(...args) { return_next_line"}
+      str.gsub!(/^rule\(:(\S+)\) do/) { "#$1(...args) { return_next_line" }
       # end  ->  }
-      str.gsub!(/^(\s*)end$/) {"#$1}"}
+      str.gsub!(/^(\s*)end$/) { "#$1}" }
 
       # arg.as(:arg) (  ->  {"arg":
       str.gsub! /arg\.as\(:arg\) \(/, '{"arg":'
       # arg.as(:arg)  ->  {"arg": null}
       str.gsub! /arg.as\(:arg\)/, '{"arg": null}'
       # ("foo" | "bar").as(:arg) (  ->  {"(bar|baz)":
-      str.gsub!(/\(([^)]+)\)\.as\(:arg\) \(/) {"{\"(#{$1.gsub('"', '').split(' | ').join('|')})\":"}
+      str.gsub!(/\(([^)]+)\)\.as\(:arg\) \(/) { "{\"(#{$1.gsub('"', '').split(' | ').join('|')})\":" }
       # enum(("foo" | "bar")).as(:arg) (  ->  {"(bar|baz)":  # TODO: support "enum" in the middle of line
-      str.gsub!(/enum\(\(([^)]+)\)\)\.as\(:arg\) \(/) {"{\"(#{$1.gsub('"', '').split(' | ').join('|')})\":"}
+      str.gsub!(/enum\(\(([^)]+)\)\)\.as\(:arg\) \(/) { "{\"(#{$1.gsub('"', '').split(' | ').join('|')})\":" }
 
       str.gsub! '.as(:arg)', ''
 
       # c(  ->  {
-      str.gsub!(/^(\s*)c\(/) {"#$1{"}
+      str.gsub!(/^(\s*)c\(/) { "#$1{" }
 
       # foo  /* doc */,  ->  foo()  /* doc */,
-      str.gsub!(%r|^(\s*)(?!arg)(\w+)(  /\* (.*) \*/,?)$|) {"#$1this.#$2()#$3"}
+      str.gsub!(%r|^(\s*)(?!arg)(\w+)(  /\* (.*) \*/,?)$|) { "#$1this.#$2()#$3" }
       # foo,  ->  foo(),
-      str.gsub!(%r|^(\s*)(?!arg)(\w+)(,?)$|) {"#$1this.#$2()#$3"}
+      str.gsub!(%r|^(\s*)(?!arg)(\w+)(,?)$|) { "#$1this.#$2()#$3" }
 
       # )  ->  }
-      str.gsub!(/^(\s+)\)/) {"#$1}"}
+      str.gsub!(/^(\s+)\)/) { "#$1}" }
 
       str
     end
@@ -81,56 +80,56 @@ module Junoser
     def process_argument_syntax(str)
       # "foo" (("bar" | "baz")) (  ->  "foo(bar|baz)": {
       # "foo" enum(("bar" | "baz")) (  ->  "foo(bar|baz)": {  # TODO: support "enum" in the middle of line
-      str.gsub!(/^(\s*)"(\S+)" (?:enum)?\(\((.*)\)\) \(/) {"#$1\"#$2(#{$3.gsub('"', '').split(' | ').join('|')})\": {"}
+      str.gsub!(/^(\s*)"(\S+)" (?:enum)?\(\((.*)\)\) \(/) { "#$1\"#$2(#{$3.gsub('"', '').split(' | ').join('|')})\": {" }
       # "foo" arg (  ->  "foo(arg)": {
-      str.gsub!(/^(\s*)"(\S+)" arg \(/) {"#$1\"#$2(arg)\": {"}
+      str.gsub!(/^(\s*)"(\S+)" arg \(/) { "#$1\"#$2(arg)\": {" }
 
       # "foo" (... | arg)  /* doc */  ->  "foo": "arg"
-      str.gsub!(%r|^(\s*)"(\S+)" \(.* \| arg ?.*\)  /\* (.*) \*/(,?)$|) {"#$1\"#$2 | #$3\": arg#$4"}
+      str.gsub!(%r|^(\s*)"(\S+)" \(.* \| arg ?.*\)  /\* (.*) \*/(,?)$|) { "#$1\"#$2 | #$3\": arg#$4" }
 
       # "foo" (... | arg) (  /* doc */  ->  "foo(arg)": {
-      str.gsub!(%r|^(\s*)"(\S+)" \(.* \| arg ?.*\) \(  /\* (.*) \*/$|) {"#$1\"#$2(arg) | #$3\": {"}
+      str.gsub!(%r|^(\s*)"(\S+)" \(.* \| arg ?.*\) \(  /\* (.*) \*/$|) { "#$1\"#$2(arg) | #$3\": {" }
       # "foo" (... | arg) (  ->  "foo(arg)": {
-      str.gsub!(%r|^(\s*)"(\S+)" \(.* \| arg ?.*\) \($|) {"#$1\"#$2(arg)\": {"}
+      str.gsub!(%r|^(\s*)"(\S+)" \(.* \| arg ?.*\) \($|) { "#$1\"#$2(arg)\": {" }
 
       # "foo" (arg | ...)  /* doc */  ->  "foo": "arg"
-      str.gsub!(%r|^(\s*)"(\S+)" \(arg ?.*\)  /\* (.*) \*/(,?)$|) {"#$1\"#$2 | #$3\": arg#$4"}
+      str.gsub!(%r|^(\s*)"(\S+)" \(arg ?.*\)  /\* (.*) \*/(,?)$|) { "#$1\"#$2 | #$3\": arg#$4" }
 
       # "foo" (arg | ...) (  /* doc */  ->  "foo(arg)": {
-      str.gsub!(%r|^(\s*)"(\S+)" \(arg ?.*\) \(  /\* (.*) \*/(,?)$|) {"#$1\"#$2(arg) | #$3\": {#$4"}
+      str.gsub!(%r|^(\s*)"(\S+)" \(arg ?.*\) \(  /\* (.*) \*/(,?)$|) { "#$1\"#$2(arg) | #$3\": {#$4" }
 
       # "foo" ("bar" | "baz") (  /* doc */  ->  "foo(bar|baz)": {
-      str.gsub!(%r|^(\s*)"(\S+)" \("([^)]+)"\) \(  /\* (.*) \*/$|) {"#$1\"#$2(#{$3.split('" | "').join('|')}) | #$4\": {"}
+      str.gsub!(%r|^(\s*)"(\S+)" \("([^)]+)"\) \(  /\* (.*) \*/$|) { "#$1\"#$2(#{$3.split('" | "').join('|')}) | #$4\": {" }
       # "foo" ("bar" | "baz") (  ->  "foo(bar|baz)": {
-      str.gsub!(%r|^(\s*)"(\S+)" \("([^)]+)"\) \($|) {"#$1\"#$2(#{$3.split('" | "').join('|')})\": {"}
+      str.gsub!(%r|^(\s*)"(\S+)" \("([^)]+)"\) \($|) { "#$1\"#$2(#{$3.split('" | "').join('|')})\": {" }
 
       # "foo" ("bar" | "baz") /* doc */,  ->  "foo": ["bar", "baz"],
-      str.gsub!(%r|^(\s*)"(\S+)" \(([^)]+)\)  /\* (.*) \*/(,?)$|) {"#$1\"#$2 | #$4\": [#{$3.split(' | ').join(', ')}]#$5"}
+      str.gsub!(%r|^(\s*)"(\S+)" \(([^)]+)\)  /\* (.*) \*/(,?)$|) { "#$1\"#$2 | #$4\": [#{$3.split(' | ').join(', ')}]#$5" }
       # "foo" ("bar" | "baz"),  ->  "foo": ["bar", "baz"],
-      str.gsub!(%r|^(\s*)"(\S+)" \(([^)]+)\)(,?)$|) {"#$1\"#$2\": [#{$3.split(' | ').join(', ')}]#$4"}
+      str.gsub!(%r|^(\s*)"(\S+)" \(([^)]+)\)(,?)$|) { "#$1\"#$2\": [#{$3.split(' | ').join(', ')}]#$4" }
 
       # "foo" enum(("bar" | "baz"))  ->  "foo": new Enumeration(["bar", "baz"])
-      str.gsub!(/^(\s*)("\S+") enum\(\((.*)\)\)/) {"#$1#$2: new Enumeration(#{$3.gsub('"', '').split(' | ')})"}
+      str.gsub!(/^(\s*)("\S+") enum\(\((.*)\)\)/) { "#$1#$2: new Enumeration(#{$3.gsub('"', '').split(' | ')})" }
 
       # "foo" arg  /* doc */,  ->  "foo | doc": "arg",
-      str.gsub!(%r|^(\s*)"([^"]+)" arg  /\* (.*) \*/(,?)$|) {"#$1\"#$2 | #$3\": \"arg\"#$4"}
+      str.gsub!(%r|^(\s*)"([^"]+)" arg  /\* (.*) \*/(,?)$|) { "#$1\"#$2 | #$3\": \"arg\"#$4" }
       # "foo" arg,  ->  "foo": "arg",
-      str.gsub!(%r|(\s*)"([^"]+)" arg(,?)$|) {"#$1\"#$2\": \"arg\"#$3"}
+      str.gsub!(%r|(\s*)"([^"]+)" arg(,?)$|) { "#$1\"#$2\": \"arg\"#$3" }
 
       # "foo" ipaddr,  -> "foo": this.ipaddr(),
-      str.gsub!(%r|(\s*)"([^"]+)" ipaddr(,?)$|) {"#$1\"#$2\": this.ipaddr()#$3"}
+      str.gsub!(%r|(\s*)"([^"]+)" ipaddr(,?)$|) { "#$1\"#$2\": this.ipaddr()#$3" }
 
       str
     end
 
     def process_structural_syntax(str)
       # "foo" (  /* doc */  ->  "foo | doc": (...args) => {
-      str.gsub!(%r|^(\s*)"(\S+)" \(  /\* (.*) \*/|) {"#$1\"#$2 | #$3\": {"}
+      str.gsub!(%r|^(\s*)"(\S+)" \(  /\* (.*) \*/|) { "#$1\"#$2 | #$3\": {" }
       # "foo" (  ->  "foo": (...args) => {
-      str.gsub!(%r|^(\s*)"(\S+)" \($|) {"#$1\"#$2\": {"}
+      str.gsub!(%r|^(\s*)"(\S+)" \($|) { "#$1\"#$2\": {" }
 
       # "foo" arg (  /* doc */  ->  "foo | doc": (...args) => {
-      str.gsub!(%r|^(\s*)"(\S+)" arg \(  /\* (.*) \*/|) {"#$1\"#$2 | #$3\": {"}
+      str.gsub!(%r|^(\s*)"(\S+)" arg \(  /\* (.*) \*/|) { "#$1\"#$2 | #$3\": {" }
 
       str
     end
@@ -142,9 +141,9 @@ module Junoser
       str.gsub!(/ ((?!arg\w)(arg)|(enum)?\(arg\))/, ' "arg"')
 
       # "foo"  /* doc */,  ->  "foo | doc": null,
-      str.gsub!(%r|^(\s*)"([^"]+)"  /\* (.*) \*/(,?)$|) {"#$1\"#$2 | #$3\": null#$4"}
+      str.gsub!(%r|^(\s*)"([^"]+)"  /\* (.*) \*/(,?)$|) { "#$1\"#$2 | #$3\": null#$4" }
       # "foo",  ->  "foo": null,
-      str.gsub!(%r|^(\s*)"([^"]+)"(,?)$|) {"#$1\"#$2\": null#$3"}
+      str.gsub!(%r|^(\s*)"([^"]+)"(,?)$|) { "#$1\"#$2\": null#$3" }
 
       # ("foo" | "bar")  ->  ["foo", "bar"]
       str.gsub!(/^(\s*) \(+("[^"]+(?:" \| "[^"]+)*")\)+(,?)$/) do
@@ -153,10 +152,10 @@ module Junoser
       end
 
       # enum(("bar" | "baz"))  ->  "foo": new Enumeration(["bar", "baz"])
-      str.gsub!(/^(\s*)enum\(\((.*)\)\)/) {"#$1new Enumeration(#{$2.gsub('"', '').split(' | ')})"}
+      str.gsub!(/^(\s*)enum\(\((.*)\)\)/) { "#$1new Enumeration(#{$2.gsub('"', '').split(' | ')})" }
 
       # (arg | "foo")  ->  ["arg", "foo"]
-      str.gsub!(/^(\s*) \(arg( \| "[^"]+")+\)/) {"#$1[\"arg\"#{$2.split(' | ').join(', ')}]"}
+      str.gsub!(/^(\s*) \(arg( \| "[^"]+")+\)/) { "#$1[\"arg\"#{$2.split(' | ').join(', ')}]" }
 
       str
     end
@@ -184,8 +183,11 @@ module Junoser
       str.gsub!(/"(dest|src|static)-nat-rule-match/) { '"match' }
 
       # faster interface speed support
-      str.gsub! '"40g", "oc3"', '"40g", "100g", "200g", "400g", "800g", "oc3"'
-      str.gsub! '"100G"', '"100G", "200G", "400G", "800G"'
+      str.gsub! '"400g", "oc3"', '"400g", "800g", "oc3"'
+      str.gsub! '"400G"', '"400G", "800G"'
+
+      # support "set interfaces xxx ether-options speed"
+      str.gsub! '"ethernet-1', '"1'
 
       fix_route_filter(str)
 
@@ -193,9 +195,9 @@ module Junoser
     end
 
     def fix_route_filter(str)
-      str.gsub!(/("exact \| [^"]*"): "arg"/) {"#$1: null"}
-      str.gsub!(/("longer \| [^"]*"): "arg"/) {"#$1: null"}
-      str.gsub!(/("orlonger \| [^"]*"): "arg"/) {"#$1: null"}
+      str.gsub!(/("exact \| [^"]*"): "arg"/) { "#$1: null" }
+      str.gsub!(/("longer \| [^"]*"): "arg"/) { "#$1: null" }
+      str.gsub!(/("orlonger \| [^"]*"): "arg"/) { "#$1: null" }
     end
 
     def process_comment(str)
@@ -203,17 +205,27 @@ module Junoser
       str.gsub! '%', '' % %''
 
       # "foo": ...  /* doc */,  ->  "foo | doc": ...,
-      str.gsub!(%r|^(\s*)"([^"]+)": (.*)  /\* (.*) \*/(,?)$|) {"#$1\"#$2 | #$4\": #$3#$5"}
+      str.gsub!(%r|^(\s*)"([^"]+)": (.*)  /\* (.*) \*/(,?)$|) { "#$1\"#$2 | #$4\": #$3#$5" }
 
       str
     end
 
     def process_lines(str)
-      # "set protocols mpls path"
+      # set protocols mpls path
       str.gsub!(/("path" arg \(.*Route of a label-switched path.*)(\s*)c\(/) do
         "#{$1}#{$2}s(#{$2}ipaddr,"
       end
 
+      # set protocols iccp peer xxx liveness-detection single-hop
+      str.gsub!(/(^rule\(:peer_group\) do.*?\n(\s*)"detection-time" \(.*?c\(\s*"threshold" arg .*?\)\s*\))/m) do
+        "#{$1},\n#{format('"single-hop"', $2)}"
+      end
+
+      # set forwarding-options dhcp-relay server-group
+      str.gsub!(/^(rule\(:(?:v6_)?server_group_type\) do)\n(.*?)\nend/m) do
+        "#{$1}\n  arg.as(:arg) (\n#{$2}\n  )\nend"
+      end
+
       str
     end
 
@@ -227,7 +239,7 @@ module Junoser
       # ->
       #
       # return ...
-      lines.gsub!(/return_next_line\n(\s*)/m) {"\n#$1return "}
+      lines.gsub!(/return_next_line\n(\s*)/m) { "\n#$1return " }
 
       # {
       #   {
@@ -236,7 +248,7 @@ module Junoser
       #
       # {
       #   "null_1": {
-      lines.gsub!(/([{,]\n\s*){/m) {"#$1\"null_#{sequence}\": {"}
+      lines.gsub!(/([{,]\n\s*){/m) { "#$1\"null_#{sequence}\": {" }
 
       # {
       #   foo()
@@ -245,10 +257,10 @@ module Junoser
       #
       # {
       #   "null_1": foo()
-      lines.gsub!(/([{,]\n\s*)([^ "(]+)/m) {"#$1\"null_#{sequence}\": #$2"}
+      lines.gsub!(/([{,]\n\s*)([^ "(]+)/m) { "#$1\"null_#{sequence}\": #$2" }
 
       # "arg"  ->  "arg_1"
-      lines.gsub('"arg":') {%["arg_#{sequence}":]}
+      lines.gsub('"arg":') { %["arg_#{sequence}":] }
     end
 
     # }  ->  )
@@ -302,12 +314,12 @@ module Junoser
 
     def objectize_arg_of_s(lines)
       # s(  ->  s({
-      lines.gsub!(/^( *(?:return|\S+:)? +)s\($/m) {"#$1this.s({"}
+      lines.gsub!(/^( *(?:return|\S+:)? +)s\($/m) { "#$1this.s({" }
       # sc(  ->  sc({
-      lines.gsub!(/^( *(?:return|\S+:)? +)sc\($/m) {"#$1this.sc({"}
+      lines.gsub!(/^( *(?:return|\S+:)? +)sc\($/m) { "#$1this.sc({" }
 
       # )  ->  })
-      lines.gsub!(/^( *)\)(,?)$/m) {"#$1})#$2"}
+      lines.gsub!(/^( *)\)(,?)$/m) { "#$1})#$2" }
 
       lines
     end

data/lib/junoser/parser.rb

@@ -3611,6 +3611,15 @@ module Junoser
                                               a(str("rotation"), arg),
                                               str("allow-duplicates")
                                           )
+                                      ),
+                                      b(str("transport"),
+                                          c(
+                                              a(str("tcp-connections"), arg),
+                                              b(str("protocol"),
+                                                (str("udp") | str("tcp") | str("tls"))
+                                              ),
+                                              a(str("tls-profile"), arg)
+                                          )
                                       )
                                   )
                               ),
@@ -22376,7 +22385,86 @@ module Junoser
                     ),
                     str("vlan-isolation")
                 )
+            ),
+            # Ported from vSRX 18.3R1.9
+            b(str("cluster"),
+                c(
+                    b(str("traceoptions"),
+                        c(
+                            str("no-remote-trace"),
+                            b(str("file"),
+                                sc(
+                                      arg,
+                                    a(str("size"), arg),
+                                    a(str("files"), arg),
+                                    str("world-readable"),
+                                    str("no-world-readable"),
+                                    b(str("match"),
+                                      regular_expression
+                                    )
+                                )
+                            ).as(:oneline),
+                            a(str("flag"), enum(str("cli") | str("configuration") | str("eventlib") | str("fsm") | str("heartbeat") | str("interface") | str("routing-socket") | str("uspipc") | str("init") | str("socket") | str("snmp") | str("ip-monitoring") | str("hw-monitoring") | str("fabric-monitoring") | str("schedule-monitoring") | str("heartbeat-tlv") | str("all"))).as(:oneline),
+                            b(str("level"),
+                              (str("emergency") | str("alert") | str("critical") | str("error") | str("warning") | str("notice") | str("info") | str("debug") | str("all"))
+                            )
+                        )
+                    ),
+                    str("control-link-recovery"),
+                    a(str("reth-count"), arg),
+                    str("control-ports").as(:oneline),
+                    a(str("heartbeat-interval"), arg),
+                    a(str("heartbeat-threshold"), arg),
+                    str("network-management"),
+                    a(str("node"), enum(str("0") | str("1"))),
+                    b(a(str("redundancy-group"), arg),
+                        c(
+                            a(str("node"), enum(str("0") | str("1")),
+                                sc(
+                                    a(str("priority"), arg)
+                                )
+                            ).as(:oneline),
+                            b(str("preempt"),
+                                c(
+                                    a(str("delay"), arg),
+                                    a(str("limit"), arg),
+                                    a(str("period"), arg)
+                                )
+                            ),
+                            a(str("gratuitous-arp-count"), arg),
+                            a(str("hold-down-interval"), arg),
+                            b(a(str("interface-monitor"), arg),
+                                sc(
+                                    a(str("weight"), arg)
+                                )
+                            ).as(:oneline),
+                            b(str("ip-monitoring"),
+                                c(
+                                    a(str("global-weight"), arg),
+                                    a(str("global-threshold"), arg),
+                                    a(str("retry-interval"), arg),
+                                    a(str("retry-count"), arg),
+                                    b(str("family"),
+                                        c(
+                                            b(str("inet"),
+                                                c(
+                                                      ip_monitoring_address_type
+                                                )
+                                            )
+                                        )
+                                    )
+                                )
+                            )
+                        )
+                    ),
+                    b(str("configuration-synchronize"),
+                        c(
+                            str("no-secondary-bootup-auto")
+                        )
+                    )
+                )
             )
+            # End of vSRX 18.3R1.9
         )
     end
 
@@ -127220,6 +127308,20 @@ module Junoser
             str("no-world-readable")
         ).as(:oneline)
     end
+
+    rule(:ip_monitoring_address_type) do
+      b(arg.as(:arg),
+        c(
+            a(str("weight"), arg),
+            b(str("interface"),
+                s(
+                        arg,
+                  a(str("secondary-ip-address"), arg)
+                )
+            )
+        )
+      )
+    end
     # End of vSRX 18.3R1.9
   end
 end

data/lib/junoser/version.rb

@@ -1,3 +1,3 @@
 module Junoser
-  VERSION = "0.5.2"
+  VERSION = "0.5.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: junoser
 version: !ruby/object:Gem::Version
-  version: 0.5.2
+  version: 0.5.3
 platform: ruby
 authors:
 - Shintaro Kojima
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-12-09 00:00:00.000000000 Z
+date: 2023-07-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parslet
@@ -150,7 +150,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.4.1
 signing_key:
 specification_version: 4
 summary: PEG parser for JUNOS configuration.