junoser 0.7.2 → 0.7.3

data/lib/junoser/ruler.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+# rubocop:disable Style/PerlBackrefs -- to simplify
+
 module Junoser
   class Ruler
     OFFSET = '    '
@@ -7,20 +11,20 @@ module Junoser
     end
 
     def to_rule
-      rule_header << rule << rule_footer
+      +rule_header << rule << rule_footer
     end
 
     def rule
       str = @rule.read
       str = remove_comments(str)
       str = process_reserved_element(str)
-      str.split(/\n/).map { |l| format(process_line(l)) }.join("\n")
+      str.split("\n").map { |l| fmt(process_line(l)) }.join("\n")
     end
 
     private
 
     def remove_comments(str)
-      str.gsub(%r(\s*/\*.*\*/), '')
+      str.gsub(%r{\s*/\*.*\*/}, '')
     end
 
     def process_line(str)
@@ -29,21 +33,31 @@ module Junoser
       str.gsub!(/("[^"]+")/) { "str(#{$1})" } # "foo" -> str("foo")
 
       str.gsub!(/^(\s*)arg(\.as\(:\S+\))? \($/) { "#{$1}b(arg#{$2}," } # arg ( -> b(arg,
-      str.gsub!(/^(\s*)(str\(\S+\)) ([^ \t\n\r\f(|,]+)(\.as\(:\S+\))?(,?)$/) { "#{$1}a(#{$2}, #{$3})#{$4}#{$5}" } # str("foo") bar -> a(str("foo"), bar)
-      str.gsub!(/^(\s*)(str\(\S+\)) (enum)?\((.*)\)(,?)$/) { "#{$1}a(#{$2}, #{$3}#{$4})#{$5}" } # str("foo") (a | b) -> a(str("foo"), a | b)
-
+      # str("foo") bar -> a(str("foo"), bar)
+      str.gsub!(/^(\s*)(str\(\S+\)) ([^ \t\n\r\f(|,]+)(\.as\(:\S+\))?(,?)$/) do
+        "#{$1}a(#{$2}, #{$3})#{$4}#{$5}"
+      end
+      # str("foo") (a | b) -> a(str("foo"), a | b)
+      str.gsub!(/^(\s*)(str\(\S+\)) (enum)?\((.*)\)(,?)$/) do
+        "#{$1}a(#{$2}, #{$3}#{$4})#{$5}"
+      end
       str.gsub!(/^(\s*)(str\(\S+\)) \($/) { "#{$1}b(#{$2}," } # str("foo") ( -> b(str("foo"),
       str.gsub!(/^(\s*)(enum)?(\(.*\))(\.as\(:\S\))? \($/) { "#{$1}b(#{$2}#{$3}#{$4}," } # (a | b) ( -> b((a | b),
-      str.gsub!(/^(\s*)(str\(\S+\)) ([^ \t\n\r\f(|,]+) \($/) { "#{$1}b(a(#{$2}, #{$3})," } # str("foo") bar ( -> b(a(str("foo"), bar),
-      str.gsub!(/^(\s*)(str\(\S+\)) (enum)?\((.*)\) \($/) { "#{$1}a(#{$2}, #{$3}#{$4}," } # str("foo") (a | b) ( -> a(str("foo"), a | b,
-
+      # str("foo") bar ( -> b(a(str("foo"), bar),
+      str.gsub!(/^(\s*)(str\(\S+\)) ([^ \t\n\r\f(|,]+) \($/) do
+        "#{$1}b(a(#{$2}, #{$3}),"
+      end
+      # str("foo") (a | b) ( -> a(str("foo"), a | b,
+      str.gsub!(/^(\s*)(str\(\S+\)) (enum)?\((.*)\) \($/) do
+        "#{$1}a(#{$2}, #{$3}#{$4},"
+      end
       str
     end
 
     def process_reserved_element(str)
-      str.gsub! /"\$\S+"/, 'arg'
+      str.gsub!(/"\$\S+"/, 'arg')
 
-      str.gsub! /"groups" \(\s*s\(\s*any\s*\)\s*\)/, <<-EOS.strip
+      str.gsub!(/"groups" \(\s*s\(\s*any\s*\)\s*\)/, <<-REPLACE.strip)
           b(a("groups", arg),
             c(
               configuration,
@@ -65,7 +79,7 @@ module Junoser
               )
             )
           )
-      EOS
+      REPLACE
 
       str.gsub! '"equal-literal"', '"="'
       str.gsub! '"plus-literal"', '"+"'
@@ -81,55 +95,55 @@ module Junoser
       str.gsub! '"tcp-flags" arg', '"tcp-flags" (quote | arg)'
 
       str.gsub!(/^(\s*)"as-path" arg \(\s*c\(\s*arg/) do
-        format(['"as-path" arg (',
-                '  c(',
-                '    quote | arg'], $1)
+        fmt(['"as-path" arg (',
+             '  c(',
+             '    quote | arg'], $1)
       end
 
       str.gsub!(/^rule\(:regular_expression\) do\s.*?\s*end/) do
-        <<~EOS
+        <<~REPLACE
           rule(:regular_expression) do
             (quote | arg).as(:arg)
           end
-        EOS
+        REPLACE
       end
 
       str.gsub!(/^rule\(:login_user_object\) do\s*arg\.as\(:arg\) \(\s*c\(\s*"full-name" arg,/) do
-        <<~EOS
+        <<~REPLACE
           rule(:login_user_object) do
             arg.as(:arg) (
               sc(
                 "full-name" (quote | arg),
-        EOS
+        REPLACE
       end
 
       str.gsub!(/^(\s*)"location" arg,\s*"contact" arg,/) do
-        format(['"location" (quote | arg),',
-                '"contact" (quote | arg),'], $1)
+        fmt(['"location" (quote | arg),',
+             '"contact" (quote | arg),'], $1)
       end
 
       str.gsub!(/^(\s*)"as-path" \(\s*c\(\s*"path" arg/) do
-        format(['"as-path" (',
-                '  c(',
-                '    "path" (quote | arg)'], $1)
+        fmt(['"as-path" (',
+             '  c(',
+             '    "path" (quote | arg)'], $1)
       end
 
       str.gsub!(/^(\s*)prefix_list_items,\s*"apply-path" arg/) do
-        format(['"apply-path" (quote | arg),',
-                'prefix_list_items'], $1)
+        fmt(['"apply-path" (quote | arg),',
+             'prefix_list_items'], $1)
       end
 
       str.gsub!(/^(\s*)"drop-profile-map" \(\s*s\(\s*"loss-priority" \(\s*(.*\s*\),)\s*"protocol" \(\s*(.*\s*\),)\s*c\(\s*"drop-profile" (.*)/) do
-        format([
-                 '"drop-profile-map" (',
-                 '  s(',
-                 '    s("loss-priority",',
-                 "      #{$2}",
-                 '    s("protocol",',
-                 "      #{$3}",
-                 '    s("drop-profile",',
-                 "      #{$4}"
-               ], $1)
+        fmt([
+              '"drop-profile-map" (',
+              '  s(',
+              '    s("loss-priority",',
+              "      #{$2}",
+              '    s("protocol",',
+              "      #{$3}",
+              '    s("drop-profile",',
+              "      #{$4}"
+            ], $1)
       end
 
       #
@@ -145,15 +159,15 @@ module Junoser
       str.gsub!(/^(rule\(:server_group_type\) do\s*)c\(\s*c\(\s*arg\s*\)\s*\)/) { "#{$1}s(arg, arg)" }
 
       str.gsub!(/^(rule\(:rib_group_inet_type\) do)\s*c\(\s*arg/) do
-        format([$1,
-                '  ca(',
-                '    a(arg, arg)'], '')
+        fmt([$1,
+             '  ca(',
+             '    a(arg, arg)'], '')
       end
 
       # Fix overkill
       str.gsub!(/^(\s*)"priority" \(\s*ca\(\s*arg\s*\)/) do
-        format(['"priority" (',
-                '  a(arg, arg)', $1])
+        fmt(['"priority" (',
+             '  a(arg, arg)', $1])
       end
 
       #
@@ -166,37 +180,37 @@ module Junoser
       #
       #   "inet",
       #   "inet6"
-      str.gsub!(/"cspf"(.*\s*.*)"cspf-link"/) { %["cspf-link"#{$1}"cspf"] }
-      str.gsub!(/"http"(.*\s*.*)"https"/) { %["https"#{$1}"http"] }
-      str.gsub!(/"inet"(.*\s*.*)"inet6"/) { %["inet6"#{$1}"inet"] }
-      str.gsub!(/"icmp"(.*\s*.*)"icmp6"/) { %["icmp6"#{$1}"icmp"] }
-      str.gsub!(/"icmp"(.*\s*.*)"icmpv6"/) { %["icmpv6"#{$1}"icmp"] }
-      str.gsub!(/"snmp"(.*\s*.*)"snmptrap"/) { %["snmptrap"#{$1}"snmp"] }
-      str.gsub!(/"ospf"(.*\s*.*)"ospf3"/) { %["ospf3"#{$1}"ospf"] }
-      str.gsub!(/"deny"(.*\s*.*)"deny-password"/) { %["deny-password"#{$1}"deny"] }
-      str.gsub!(/"no-redirects"(.*\s*.*)"no-redirects-ipv6"/) { %["no-redirects-ipv6"#{$1}"no-redirects"] }
-      str.gsub!(/"chassis"([^()]*)"chassis-ha-reswatch"/m) { %["chassis-ha-reswatch"#{$1}"chassis"] }
+      str.gsub!(/"cspf"(.*\s*.*)"cspf-link"/) { %("cspf-link"#{$1}"cspf") }
+      str.gsub!(/"http"(.*\s*.*)"https"/) { %("https"#{$1}"http") }
+      str.gsub!(/"inet"(.*\s*.*)"inet6"/) { %("inet6"#{$1}"inet") }
+      str.gsub!(/"icmp"(.*\s*.*)"icmp6"/) { %("icmp6"#{$1}"icmp") }
+      str.gsub!(/"icmp"(.*\s*.*)"icmpv6"/) { %("icmpv6"#{$1}"icmp") }
+      str.gsub!(/"snmp"(.*\s*.*)"snmptrap"/) { %("snmptrap"#{$1}"snmp") }
+      str.gsub!(/"ospf"(.*\s*.*)"ospf3"/) { %("ospf3"#{$1}"ospf") }
+      str.gsub!(/"deny"(.*\s*.*)"deny-password"/) { %("deny-password"#{$1}"deny") }
+      str.gsub!(/"no-redirects"(.*\s*.*)"no-redirects-ipv6"/) { %("no-redirects-ipv6"#{$1}"no-redirects") }
+      str.gsub!(/"chassis"([^()]*)"chassis-ha-reswatch"/m) { %("chassis-ha-reswatch"#{$1}"chassis") }
       str.gsub! '"tls1" | "tls11" | "tls12"', '"tls11" | "tls12" | "tls1"'
       str.gsub!(/("group1" \| "group2" \| "group5") \| ([^)]+)/) { "#{$2} | #{$1}" }
 
       %w[ccc ethernet-over-atm tcc vpls bridge].each do |encap|
-        str.gsub!(/"ethernet"(.*)"ethernet-#{encap}"/) { %["ethernet-#{encap}"#{$1}"ethernet"] }
+        str.gsub!(/"ethernet"(.*)"ethernet-#{encap}"/) { %("ethernet-#{encap}"#{$1}"ethernet") }
       end
 
       str.gsub!(/^(\s*)"path" arg \(\s*c\(\s*sc\(\s*"abstract",\s*c\(\s*"loose",\s*"loose-link",\s*"strict"\s*\)\s*\)\.as\(:oneline\)/) do
-        format(['"path" arg (',
-                '  c(',
-                '    b(',
-                '      ipaddr,',
-                '      c(',
-                '        "abstract",',
-                '        c(',
-                '          "loose-link",',
-                '          "loose",',
-                '          "strict"',
-                '        )',
-                '      ).as(:oneline)',
-                '    )', $1])
+        fmt(['"path" arg (',
+             '  c(',
+             '    b(',
+             '      ipaddr,',
+             '      c(',
+             '        "abstract",',
+             '        c(',
+             '          "loose-link",',
+             '          "loose",',
+             '          "strict"',
+             '        )',
+             '      ).as(:oneline)',
+             '    )', $1])
       end
 
       #
@@ -207,7 +221,7 @@ module Junoser
       str.gsub!(/\((.*) \| "vlan-id"\)/) { "(#{$1} | arg)" }
 
       %w[filename].each do |key|
-        str.gsub! %["#{key}" arg], 'arg'
+        str.gsub! %("#{key}" arg), 'arg'
       end
 
       # "filename" fix above leaves "arg". Move to the end
@@ -226,14 +240,16 @@ module Junoser
       # Fix .xsd: "arg" is missing
       #
       str.gsub!(/"route-filter" (\(\s*control_route_filter_type\s*\))/) { %["route-filter" arg #{$1}.as(:oneline)] }
-      str.gsub!(/"source-address-filter" (\(\s*control_source_address_filter_type\s*\))/) { %["source-adress-filter" arg #{$1}.as(:oneline)] }
+      str.gsub!(/"source-address-filter" (\(\s*control_source_address_filter_type\s*\))/) do
+        %["source-adress-filter" arg #{$1}.as(:oneline)]
+      end
       %w[file].each do |key|
         str.gsub!(/^(\s*"#{key}" \(\s*)c\(\s*arg,/) { "#{$1}sca(" }
       end
 
       # Fix .xsd: Unnecessary "arg" is added
       %w[exact longer orlonger].each do |key|
-        str.gsub!(/^(\s*"#{key}") arg/) { "#{$1}" }
+        str.gsub!(/^(\s*"#{key}") arg/) { $1.to_s }
       end
 
       # Fix .xsd: "ieee-802.3ad" is invalid
@@ -247,7 +263,7 @@ module Junoser
 
       # Fix .xsd: "from-zone" arg is also required
       str.gsub!(/^        "policy" \(\s*s\(\s*arg,\s*"to-zone-name" arg,\s*(.*?)\s*\)\s*^        \),/m) do
-        format(['b(', '  s("from-zone", arg, "to-zone", arg),', "      #$1", '),'], '        ')
+        fmt(['b(', '  s("from-zone", arg, "to-zone", arg),', "      #{$1}", '),'], '        ')
       end
 
       # Fix .xsd: "members" accepts [ foo bar ]
@@ -282,18 +298,20 @@ module Junoser
 
       # Fix .xsd: support "set protocols iccp peer xxx liveness-detection single-hop"
       str.gsub!(/(^rule\(:peer_group\) do.*?\n(\s*)"detection-time" \(\s*c\(\s*"threshold" arg\s*\)\s*\))/m) do
-        "#{$1},\n#{format('"single-hop"', $2)}"
+        "#{$1},\n#{fmt('"single-hop"', $2)}"
       end
 
       # Fix .xsd: support "set interfaces xxx ether-options speed"
       str.gsub! '"ethernet-1', '"1'
 
       # Fix .xsd: support "set policy-options policy-statement xxx from policy [expression]"
-      str.gsub!(/^rule\(:policy_algebra\) do(\s*)arg\.as\(:arg\)\send/) { "rule(:policy_algebra) do#{$1}any.as(:arg)\nend" }
+      str.gsub!(/^rule\(:policy_algebra\) do(\s*)arg\.as\(:arg\)\send/) do
+        "rule(:policy_algebra) do#{$1}any.as(:arg)\nend"
+      end
 
       # Fix .xsd: support "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
 
       # Fix .xsd: arg should be regular_expression
@@ -302,7 +320,7 @@ module Junoser
       str
     end
 
-    def format(str, offset = OFFSET)
+    def fmt(str, offset = OFFSET)
       case str
       when String
         str.empty? ? '' : offset + str
@@ -314,107 +332,109 @@ module Junoser
     end
 
     def rule_header
-      <<-EOS
-require 'parslet'
-
-module Junoser
-  class Parser < Parslet::Parser
-    def parse_lines(config)
-      lines = config.split("\\n").map(&:strip)
-      lines_without_deactivate = lines.reject {|l| l =~ /^deactivate/ }
-
-      lines.inject(true) do |passed, line|
-        passed & parse_line(line, lines_without_deactivate)
-      end
-    end
-
-    def parse_line(line, lines_without_deactivate)
-      if line =~ /^deactivate/
-        if lines_without_deactivate.grep(/^\#{line.sub(/^deactivate/, 'set')}/).empty?
-          $stderr.puts %(Corresponding "set" statement is not found:  \#{line})
-          return false
-        else
-          return true
-        end
-      end
-
-      begin
-        # .xsd doesn't include "apply-groups"
-        if line =~ /(.*)\\s+apply-groups(-except)?\\s+(\\S+|\\[.*\\])$/
-          return \$1 == 'set' ? true : parse(\$1)
-        end
-
-        parse line
-        true
-      rescue Parslet::ParseFailed
-        $stderr.puts "Invalid syntax:  \#{line}"
-        false
-      end
-    end
-
-    # block with children maybe
-    def b(object, *children)
-      children.inject(object) {|rule, child| rule.as(:label) >> (space >> child.as(:child) | eos) }
-    end
-
-    # with an argument, and children maybe
-    def a(object, arg, *children)
-      b(object.as(:statement) >> space >> arg.as(:argument), *children)
-    end
-
-    # choice
-    def c(*objects)
-      objects.inject {|rule, object| rule | object }
-    end
-
-    def ca(*objects)
-      objects.inject {|rule, object| rule | object } | arg
-    end
-
-    # sequence
-    def s(*objects)
-      # TODO:  eval "minOccurs" attribute of choice element
-      objects.inject {|rule, object| rule >> (space >> object).maybe }
-    end
-
-    # sequential choice
-    def sc(*objects)
-      (c(*objects) >> space.maybe).repeat(0)
-    end
-
-    def sca(*objects)
-      (c(*objects, arg) >> space.maybe).repeat(0)
-    end
-
-    def enum(object)
-      (object.as(:enum))
-    end
-
-    rule(:arg)     { match('\\S').repeat(1) }
-    rule(:space)   { match('\\s').repeat(1) }
-    rule(:any)     { match('.').repeat(1) }
-    rule(:eos)     { match('$') }
-    rule(:dotted)  { match('[^. \\t\\n\\r\\f]').repeat(1) >> str('.') >> match('[^. \\t\\n\\r\\f]').repeat(1) }
-    rule(:quote)   { str('"') >> match('[^"]').repeat(1) >> str('"') }
-    rule(:address) { match('[0-9a-fA-F:\.]').repeat(1) }
-    rule(:prefix ) { address >> (str('/') >> match('[0-9]').repeat(1)).maybe }
-
-    root(:set)
-    rule(:set) { str('set') >> space >> configuration.as(:config) >> comment.maybe }
-
-    rule(:comment) { space.maybe >> (hash_comment | slash_asterisk) }
-    rule(:hash_comment) { str('#') >> any.maybe }
-    rule(:slash_asterisk) { str('/*') >> match('(?!\\*\\/).').repeat(0) >> str('*/') }
-
-      EOS
+      <<~HEADER
+        require 'parslet'
+
+        module Junoser
+          class Parser < Parslet::Parser
+            def parse_lines(config)
+              lines = config.split("\\n").map(&:strip)
+              lines_without_deactivate = lines.reject {|l| l =~ /^deactivate/ }
+
+              lines.inject(true) do |passed, line|
+                passed & parse_line(line, lines_without_deactivate)
+              end
+            end
+
+            def parse_line(line, lines_without_deactivate)
+              if line =~ /^deactivate/
+                if lines_without_deactivate.grep(/^\#{line.sub(/^deactivate/, 'set')}/).empty?
+                  $stderr.puts %(Corresponding "set" statement is not found:  \#{line})
+                  return false
+                else
+                  return true
+                end
+              end
+
+              begin
+                # .xsd doesn't include "apply-groups"
+                if line =~ /(.*)\\s+apply-groups(-except)?\\s+(\\S+|\\[.*\\])$/
+                  return $1 == 'set' ? true : parse($1)
+                end
+
+                parse line
+                true
+              rescue Parslet::ParseFailed
+                $stderr.puts "Invalid syntax:  \#{line}"
+                false
+              end
+            end
+
+            # block with children maybe
+            def b(object, *children)
+              children.inject(object) {|rule, child| rule.as(:label) >> (space >> child.as(:child) | eos) }
+            end
+
+            # with an argument, and children maybe
+            def a(object, arg, *children)
+              b(object.as(:statement) >> space >> arg.as(:argument), *children)
+            end
+
+            # choice
+            def c(*objects)
+              objects.inject {|rule, object| rule | object }
+            end
+
+            def ca(*objects)
+              objects.inject {|rule, object| rule | object } | arg
+            end
+
+            # sequence
+            def s(*objects)
+              # TODO:  eval "minOccurs" attribute of choice element
+              objects.inject {|rule, object| rule >> (space >> object).maybe }
+            end
+
+            # sequential choice
+            def sc(*objects)
+              (c(*objects) >> space.maybe).repeat(0)
+            end
+
+            def sca(*objects)
+              (c(*objects, arg) >> space.maybe).repeat(0)
+            end
+
+            def enum(object)
+              (object.as(:enum))
+            end
+
+            rule(:arg)     { match('\\S').repeat(1) }
+            rule(:space)   { match('\\s').repeat(1) }
+            rule(:any)     { match('.').repeat(1) }
+            rule(:eos)     { match('$') }
+            rule(:dotted)  { match('[^. \\t\\n\\r\\f]').repeat(1) >> str('.') >> match('[^. \\t\\n\\r\\f]').repeat(1) }
+            rule(:quote)   { str('"') >> match('[^"]').repeat(1) >> str('"') }
+            rule(:address) { match('[0-9a-fA-F:.]').repeat(1) }
+            rule(:prefix ) { address >> (str('/') >> match('[0-9]').repeat(1)).maybe }
+
+            root(:set)
+            rule(:set) { str('set') >> space >> configuration.as(:config) >> comment.maybe }
+
+            rule(:comment) { space.maybe >> (hash_comment | slash_asterisk) }
+            rule(:hash_comment) { str('#') >> any.maybe }
+            rule(:slash_asterisk) { str('/*') >> match('(?!\\*\\/).').repeat(0) >> str('*/') }
+
+      HEADER
     end
 
     def rule_footer
-      <<-EOS
+      <<~FOOTER
 
-  end
-end
-      EOS
+          end
+        end
+      FOOTER
     end
   end
 end
+
+# rubocop:enable Style/PerlBackrefs

data/lib/junoser/squash.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'junoser'
 require 'parslet'
 
@@ -22,9 +24,9 @@ module Junoser
         when /^activate /
           delete_lines l.gsub(/^activate /, 'deactivate ')
         when /^insert (.*) before (.*)/
-          insert_before "set #{$1}", $2
+          insert_before "set #{::Regexp.last_match(1)}", ::Regexp.last_match(2)
         when /^insert (.*) after (.*)/
-          insert_after "set #{$1}", $2
+          insert_after "set #{::Regexp.last_match(1)}", ::Regexp.last_match(2)
         end
       end
 
@@ -36,11 +38,11 @@ module Junoser
 
     def remove_command_context(lines)
       lines.each_with_index do |l, i|
-        lines[i..-1].each do |l2|
-          if l2[-1] == " "  # l2 is a command context
-            lines.delete(l2) if l.include?(l2) and l != l2
-          else  # l2 has argument
-            lines.delete(l2) if l.include?("#{l2} ")
+        lines[i..].each do |l2|
+          if l2[-1] == ' ' # l2 is a command context
+            lines.delete(l2) if l.include?(l2) && (l != l2)
+          elsif l.include?("#{l2} ") # l2 has argument
+            lines.delete(l2)
           end
         end
       end
@@ -48,24 +50,24 @@ module Junoser
 
     def delete_lines(pattern)
       @lines.each do |l|
-        l.sub!(/#{pattern}/) { $1 }
+        l.sub!(/#{pattern}/) { ::Regexp.last_match(1) }
       end
     end
 
     def split_last_token(line)
       tokens = join_arg(@transformer.apply(@parser.parse(line))).split("\n")
-      tokens.map! { |t|
-        t.gsub!(/arg\((.*)\)/) { "#$1" } # Strip arg
+      tokens.map! do |t|
+        t.gsub!(/arg\((.*)\)/) { ::Regexp.last_match(1).to_s } # Strip arg
         Regexp.escape(t.strip)
-      }
+      end
 
       [tokens[0..-2].join(' '), tokens.last]
     end
 
     # Ported from lib/junoser/display/config_store.rb
     def join_arg(str)
-      str.gsub!(/\narg\((.*)\)$/) { " #$1" }
-      str.gsub!(/arg\((.*)\)/) { "#$1" }
+      str.gsub!(/\narg\((.*)\)$/) { " #{::Regexp.last_match(1)}" }
+      str.gsub!(/arg\((.*)\)/) { ::Regexp.last_match(1).to_s }
       str
     end
 
@@ -76,7 +78,7 @@ module Junoser
 
     def insert_before(statement_to_insert, key_statement)
       key_tokens = key_statement.strip.split
-      key_statement = (statement_to_insert.strip.split[0..-(key_tokens.size+1)] + key_tokens).join(' ')
+      key_statement = (statement_to_insert.strip.split[0..-(key_tokens.size + 1)] + key_tokens).join(' ')
 
       lines_to_insert = @lines.select { |l| l.include?(statement_to_insert) }
       @lines.reject! { |l| l.include?(statement_to_insert) }

data/lib/junoser/transformer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'parslet'
 
 module Junoser
@@ -24,7 +26,7 @@ module Junoser
 
     rule(label: simple(:label), child: sequence(:children)) do
       Junoser::Transformer.remove_slash_asterisk children
-      %[#{label}\n#{children.join("\n")}]
+      %(#{label}\n#{children.join("\n")})
     end
 
     rule(statement: simple(:statement), argument: simple(:argument)) do
@@ -33,7 +35,7 @@ module Junoser
 
     rule(statement: simple(:statement), argument: sequence(:arguments)) do
       Junoser::Transformer.remove_slash_asterisk arguments
-      %[#{statement}\n#{arguments.join("\n")}]
+      %(#{statement}\n#{arguments.join("\n")})
     end
 
     rule(oneline: simple(:str)) do
@@ -52,15 +54,14 @@ module Junoser
       strs.join(' ')
     end
 
-
     def self.remove_slash_asterisk(array)
       open = array.index("arg(/*)\n")
-      close = array.index("arg(*/)")
+      close = array.index('arg(*/)')
+
+      return unless open && close
 
-      if open && close
-        (open..close).reverse_each do |i|
-          array.delete_at i
-        end
+      (open..close).reverse_each do |i|
+        array.delete_at i
       end
     end
   end

data/lib/junoser/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Junoser
-  VERSION = "0.7.2"
+  VERSION = '0.7.3'
 end