junoser 0.7.2 → 0.7.3

data/lib/junoser/js_ruler.rb

@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+
+# rubocop:disable Style/PerlBackrefs -- to simplify
+
 module Junoser
   class JsRuler
-
     def initialize(input)
       @rule = input
       @sequence = 0
@@ -11,15 +14,15 @@ module Junoser
     end
 
     def to_rule
-      rule_header << rule.gsub(/^/, '  ') << rule_footer
+      +rule_header << rule.gsub(/^/, '  ') << rule_footer
     end
 
     def rule
       str = @rule.read
       str = process_lines(str)
-      str = str.split(/\n/).map { |l|
+      str = str.split("\n").map do |l|
         process_line(l) unless l =~ /^ *#/ # Skip additional comment lines
-      }.compact.join("\n")
+      end.compact.join("\n")
       finalize(str)
     end
 
@@ -27,7 +30,7 @@ module Junoser
 
     def process_lines(str)
       # set groups
-      str.gsub! /"groups" \(.*\s*s\(\s*any\s*\)\s*\)/, <<-EOS.strip
+      str.gsub!(/"groups" \(.*\s*s\(\s*any\s*\)\s*\)/, <<-REPLACE.strip)
           "groups" arg (  /* Configuration groups */
             c(
               this.configuration({ groups: false }),
@@ -47,7 +50,7 @@ module Junoser
               )
             )
           )
-      EOS
+      REPLACE
 
       # set protocols mpls path
       str.gsub!(/("path" arg \(.*Route of a label-switched path.*)(\s*)c\(/) do
@@ -56,7 +59,7 @@ module Junoser
 
       # 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)}"
+        %(#{$1},\n#{$2}"single-hop")
       end
 
       # set forwarding-options dhcp-relay server-group
@@ -66,7 +69,7 @@ module Junoser
 
       # set interfaces xxx enable
       str.gsub!(/^(rule\(:interfaces_type\) do\s*[^\n]*\s*c\()(\s*)/m) do
-        %[#{$1}#{$2}"enable",#{$2}]
+        %(#{$1}#{$2}"enable",#{$2})
       end
 
       str
@@ -79,30 +82,28 @@ module Junoser
       str = process_structural_syntax(str)
       str = process_word(str)
       str = process_reserved_word(str)
-      str = process_comment(str)
-
-      str
+      process_comment(str)
     end
 
     def remove_undefined_variables(str)
       str.gsub! '.as(:oneline)', ''
 
       # "$junos-interface-unit" |
-      str.gsub! /"\$[\w-]+" \| /, ''
+      str.gsub!(/"\$[\w-]+" \| /, '')
 
       str
     end
 
     def process_common_syntax(str)
       # rule(:foo) do  ->  foo(opts) {
-      str.gsub!(/^rule\(:(\S+)\) do/) { "#$1(opts) { return_next_line" }
+      str.gsub!(/^rule\(:(\S+)\) do/) { "#{$1}(opts) { return_next_line" }
       # end  ->  }
-      str.gsub!(/^(\s*)end$/) { "#$1}" }
+      str.gsub!(/^(\s*)end$/) { "#{$1}}" }
 
       # arg.as(:arg) (  ->  {"arg":
-      str.gsub! /arg\.as\(:arg\) \(/, '{"arg":'
+      str.gsub!('arg.as(:arg) (', '{"arg":')
       # arg.as(:arg)  ->  {"arg": null}
-      str.gsub! /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('|')})\":" }
       # enum(("foo" | "bar")).as(:arg) (  ->  {"(bar|baz)":  # TODO: support "enum" in the middle of line
@@ -111,15 +112,15 @@ module Junoser
       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+)(  /\* (.*) \*/,?)$}) { "#{$1}this.#{$2}()#{$3}" }
       # foo,  ->  foo(),
-      str.gsub!(%r|^(\s*)(?!arg)(\w+)(,?)$|) { "#$1this.#$2()#$3" }
+      str.gsub!(/^(\s*)(?!arg)(\w+)(,?)$/) { "#{$1}this.#{$2}()#{$3}" }
 
       # )  ->  }
-      str.gsub!(/^(\s+)\)/) { "#$1}" }
+      str.gsub!(/^(\s+)\)/) { "#{$1}}" }
 
       str
     end
@@ -127,56 +128,62 @@ 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)?\(\((.*)\)\) \(/) do
+        "#{$1}\"#{$2}(#{$3.gsub('"', '').split(' | ').join('|')})\": {"
+      end
       # "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!(/^(\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+)" \("([^)]+)"\) \(  /\* (.*) \*/$}) do
+        "#{$1}\"#{$2}(#{$3.split('" | "').join('|')}) | #{$4}\": {"
+      end
       # "foo" ("bar" | "baz") (  ->  "foo(bar|baz)": {
-      str.gsub!(%r|^(\s*)"(\S+)" \("([^)]+)"\) \($|) { "#$1\"#$2(#{$3.split('" | "').join('|')})\": {" }
+      str.gsub!(/^(\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+)" \(([^)]+)\)  /\* (.*) \*/(,?)$}) do
+        "#{$1}\"#{$2} | #{$4}\": [#{$3.split(' | ').join(', ')}]#{$5}"
+      end
       # "foo" ("bar" | "baz"),  ->  "foo": ["bar", "baz"],
-      str.gsub!(%r|^(\s*)"(\S+)" \(([^)]+)\)(,?)$|) { "#$1\"#$2\": [#{$3.split(' | ').join(', ')}]#$4" }
+      str.gsub!(/^(\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!(/(\s*)"([^"]+)" arg(,?)$/) { "#{$1}\"#{$2}\": \"arg\"#{$3}" }
 
       # "foo" ipaddr,  -> "foo": this.ipaddr(),
-      str.gsub!(%r|(\s*)"([^"]+)" ipaddr(,?)$|) { "#$1\"#$2\": this.ipaddr()#$3" }
+      str.gsub!(/(\s*)"([^"]+)" ipaddr(,?)$/) { "#{$1}\"#{$2}\": this.ipaddr()#{$3}" }
 
       str
     end
 
     def process_structural_syntax(str)
       # "foo" (  /* doc */  ->  "foo | doc": (opts) => {
-      str.gsub!(%r|^(\s*)"(\S+)" \(  /\* (.*) \*/|) { "#$1\"#$2 | #$3\": {" }
+      str.gsub!(%r{^(\s*)"(\S+)" \(  /\* (.*) \*/}) { "#{$1}\"#{$2} | #{$3}\": {" }
       # "foo" (  ->  "foo": (opts) => {
-      str.gsub!(%r|^(\s*)"(\S+)" \($|) { "#$1\"#$2\": {" }
+      str.gsub!(/^(\s*)"(\S+)" \($/) { "#{$1}\"#{$2}\": {" }
 
       # "foo" arg (  /* doc */  ->  "foo | doc": (opts) => {
-      str.gsub!(%r|^(\s*)"(\S+)" arg \(  /\* (.*) \*/|) { "#$1\"#$2 | #$3\": {" }
+      str.gsub!(%r{^(\s*)"(\S+)" arg \(  /\* (.*) \*/}) { "#{$1}\"#{$2} | #{$3}\": {" }
 
       str
     end
@@ -188,21 +195,21 @@ 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!(/^(\s*)"([^"]+)"(,?)$/) { "#{$1}\"#{$2}\": null#{$3}" }
 
       # ("foo" | "bar")  ->  ["foo", "bar"]
       str.gsub!(/^(\s*) \(+("[^"]+(?:" \| "[^"]+)*")\)+(,?)$/) do
         comma = $3
-        "#$1#{$2.gsub('"', '').split(' | ')}#{comma}"
+        "#{$1}#{$2.gsub('"', '').split(' | ')}#{comma}"
       end
 
       # enum(("bar" | "baz"))  ->  "foo": new Enumeration(["bar", "baz"])
-      str.gsub!(/^(\s*)enum\(\((.*)\)\)/) { "#$1new Enumeration(#{$2.gsub('"', '').split(' | ')})" }
+      str.gsub!(/^(\s*)enum\(\((.*)\)\)/) { "#{$1}new 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
@@ -242,17 +249,14 @@ 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)
-      # %  ->  %%
-      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
@@ -267,7 +271,7 @@ module Junoser
       # ->
       #
       # return ...
-      lines.gsub!(/return_next_line\n(\s*)/m) { "\n#$1return " }
+      lines.gsub!(/return_next_line\n(\s*)/m) { "\n#{$1}return " }
 
       # {
       #   {
@@ -276,7 +280,7 @@ module Junoser
       #
       # {
       #   "null_1": {
-      lines.gsub!(/([{,]\n\s*){/m) { "#$1\"null_#{sequence}\": {" }
+      lines.gsub!(/([{,]\n\s*){/m) { "#{$1}\"null_#{sequence}\": {" }
 
       # {
       #   foo()
@@ -285,10 +289,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}":) }
 
       conditional_groups(lines)
     end
@@ -298,13 +302,15 @@ module Junoser
       # Fixes
       lines.gsub! 'Timeslots (1..24;', 'Timeslots (1..24);'
       lines.gsub! '(such that the VLAN range is x <= range <= y.', '(such that the VLAN range is x <= range <= y).'
-      lines.gsub! '(intended primarily for use with a peer or group"', '(intended primarily for use with a peer or group)"'
+      lines.gsub! '(intended primarily for use with a peer or group"',
+                  '(intended primarily for use with a peer or group)"'
       lines.gsub! '(e.g. QSFP28 and QSFP+,', '(e.g. QSFP28 and QSFP+),'
-      lines.gsub! '(see the description of policy evaluation at the top of this module."', '(see the description of policy evaluation at the top of this module)."'
+      lines.gsub! '(see the description of policy evaluation at the top of this module."',
+                  '(see the description of policy evaluation at the top of this module)."'
 
       count = 0
       target = nil
-      buf = ''
+      buf = +''
       stack = []
 
       lines.each_char do |c|
@@ -344,12 +350,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) { "#{$1}this.s({" }
       # sc(  ->  sc({
-      lines.gsub!(/^( *(?:return|\S+:)? +)sc\($/m) { "#$1this.sc({" }
+      lines.gsub!(/^( *(?:return|\S+:)? +)sc\($/m) { "#{$1}this.sc({" }
 
       # )  ->  })
-      lines.gsub!(/^( *)\)(,?)$/m) { "#$1})#$2" }
+      lines.gsub!(/^( *)\)(,?)$/m) { "#{$1}})#{$2}" }
 
       lines
     end
@@ -360,13 +366,13 @@ module Junoser
       # (opts === undefined || opts?.configuration !== false) && { "null_13264": this.configuration(false) },
       #
       # ref: process_lines()
-      lines.gsub(/("groups\(arg\) \| .*":) {/) {
+      lines.gsub(/("groups\(arg\) \| .*":) {/) do
         "#{$1} opts?.groups !== false && {"
-      }
+      end
     end
 
     def rule_header
-      <<~EOS
+      <<~HEADER
         /* eslint-disable semi */
 
         class Enumeration {
@@ -405,17 +411,19 @@ module Junoser
             return new Repeatable(obj);
           }
 
-      EOS
+      HEADER
     end
 
     def rule_footer
-      <<~EOS
+      <<~FOOTER
 
         }
 
         // eslint-disable-next-line no-undef
         module.exports = {JunosSchema, Enumeration, Repeatable, Sequence};
-      EOS
+      FOOTER
     end
   end
 end
+
+# rubocop:enable Style/PerlBackrefs

data/lib/junoser/parser.rb

@@ -23779,6 +23779,162 @@ module Junoser
                     str("use-actual-mac-on-physical-interfaces"),
                     str("use-active-child-mac-on-reth")
                 )
+            ),
+            b(str("high-availability"),
+                c(
+                    str("hardware-upgrade"),
+                    b(str("local-id"),
+                        sc(
+                              arg,
+                            b(str("local-ip"),
+                              ipaddr
+                            )
+                        )
+                    ).as(:oneline),
+                    b(a(str("peer-id"), arg),
+                        c(
+                            a(str("desc"), arg),
+                            b(str("peer-ip"),
+                              ipaddr
+                            ),
+                            b(str("interface"),
+                              interface_name
+                            ),
+                            a(str("routing-instance"), arg),
+                            a(str("vpn-profile"), arg),
+                            b(str("liveness-detection"),
+                                c(
+                                    b(str("version"),
+                                      (str("0") | str("1") | str("automatic"))
+                                    ),
+                                    a(str("minimum-interval"), arg),
+                                    a(str("minimum-transmit-interval"), arg),
+                                    a(str("minimum-receive-interval"), arg),
+                                    a(str("multiplier"), arg),
+                                    c(
+                                      str("no-adaptation")
+                                    ),
+                                    b(str("transmit-interval"),
+                                        c(
+                                            a(str("minimum-interval"), arg),
+                                            a(str("threshold"), arg)
+                                        )
+                                    ),
+                                    b(str("detection-time"),
+                                        c(
+                                            a(str("threshold"), arg)
+                                        )
+                                    )
+                                )
+                            )
+                        )
+                    ),
+                    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("health-monitoring") | str("schedule-monitoring") | str("heartbeat-tlv") | str("ha-peer") | str("srg") | 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"))
+                            )
+                        )
+                    ),
+                    b(a(str("services-redundancy-group"), arg),
+                        c(
+                            a(str("shutdown-on-failure"), arg),
+                            b(str("deployment-type"),
+                              (str("cloud") | str("hybrid") | str("routing") | str("switching"))
+                            ),
+                            b(str("peer-id"),
+                                c(
+                                      arg
+                                )
+                            ),
+                            b(str("activeness-probe"),
+                                c(
+                                    b(str("dest-ip"),
+                                        c(
+                                            b(str("src-ip"),
+                                              ipaddr
+                                            ),
+                                            a(str("routing-instance"), arg),
+                                              ipaddr
+                                        )
+                                    ),
+                                    a(str("minimum-interval"), arg),
+                                    a(str("multiplier"), arg)
+                                )
+                            ),
+                            b(a(str("virtual-ip"), arg),
+                                c(
+                                    b(str("ip"),
+                                      ipprefix_mandatory
+                                    ),
+                                    b(str("interface"),
+                                      interface_name
+                                    ),
+                                    str("use-virtual-mac")
+                                )
+                            ),
+                            b(str("monitor"),
+                                c(
+                                    b(a(str("ip"), arg),
+                                        c(
+                                            a(str("routing-instance"), arg)
+                                        )
+                                    ),
+                                    b(a(str("bfd-liveliness"), arg),
+                                        c(
+                                            b(str("src-ip"),
+                                              ipv4addr
+                                            ),
+                                            a(str("routing-instance"), arg),
+                                            b(str("session-type"),
+                                              (str("singlehop") | str("multihop"))
+                                            ),
+                                            b(str("interface"),
+                                              interface_name
+                                            )
+                                        )
+                                    ),
+                                    a(str("interface"), arg)
+                                )
+                            ),
+                            b(str("active-signal-route"),
+                                c(
+                                      ipv4addr,
+                                    a(str("routing-instance"), arg)
+                                )
+                            ),
+                            b(str("backup-signal-route"),
+                                c(
+                                      ipv4addr,
+                                    a(str("routing-instance"), arg)
+                                )
+                            ),
+                            b(a(str("prefix-list"), arg),
+                                c(
+                                    a(str("routing-instance"), arg)
+                                )
+                            ),
+                            a(str("managed-services"), enum(str("ipsec"))).as(:oneline),
+                            str("preemption"),
+                            str("process-packet-on-backup"),
+                            a(str("activeness-priority"), arg)
+                        )
+                    )
+                )
             )
             # End of vSRX 22.4R1.10
         )

data/lib/junoser/rule_tree/node.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Junoser
   module RuleTree
     class Node
@@ -14,7 +16,7 @@ module Junoser
       end
 
       def print(level = 0)
-        puts INDENT * level + "- #{@name}"
+        puts (INDENT * level) + "- #{@name}"
         @children.each do |child|
           child.print level + 1
         end

data/lib/junoser/rule_tree/parser.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Junoser
   module RuleTree
     class Parser
@@ -20,7 +22,7 @@ module Junoser
 
         validate_uniq rules[root_index..].map(&:first)
 
-        @nodes = Hash[rules[root_index..].map { |name, _| [name, Node.new(name)] }]
+        @nodes = rules[root_index..].to_h { |name, _| [name, Node.new(name)] }
         used = Set.new
 
         rules[root_index..].map do |name, refs|
@@ -30,6 +32,7 @@ module Junoser
           used += children
           children.each do |child|
             raise %(Unknown rule: #{child}) unless @nodes[child]
+
             @nodes[name] << @nodes[child]
           end
         end
@@ -40,11 +43,11 @@ module Junoser
       private
 
       def content
-        @_content ||= @content
-                        .gsub(%r| */\*.*\*/|, '')
-                        .gsub(/\.as\(:oneline\)/, '')
-                        .gsub(/^(?!rule.*).*["#()].*\n/, '')
-                        .gsub(/ *arg,?\n/, '')
+        @content ||= @content
+                     .gsub(%r{ */\*.*\*/}, '')
+                     .gsub('.as(:oneline)', '')
+                     .gsub(/^(?!rule.*).*["#()].*\n/, '')
+                     .gsub(/ *arg,?\n/, '')
       end
 
       def validate_uniq(rules)
@@ -58,8 +61,8 @@ module Junoser
         unused = all - used - %w[configuration]
         return if unused.empty?
 
-        $stderr.puts 'Warning: Unused rules:'
-        unused.each { |r| $stderr.puts "  - #{r}" }
+        warn 'Warning: Unused rules:'
+        unused.each { |r| warn "  - #{r}" }
       end
     end
   end

data/lib/junoser/rule_tree.rb

@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 require 'junoser/rule_tree/node'
 require 'junoser/rule_tree/parser'