Automatic update of rubocop violations

Add exclusions for:

    Layout/IndentHeredoc,
    Metrics/BlockNesting:
    Metrics/LineLength:
    Style/AccessorMethodName:
    Style/DoubleNegation:
    Style/MultipleComparison:
    Style/NumericPredicate:
    Style/PredicateName:
    Style/SignalException:
    Style/VariableName:

SignalException is disabled because Puppet::Type#fail overrides Kernel#fail,
and we really do want fail and not raise.

1 files changed, 206 insertions, 208 deletions

diff --git a/lib/puppet/provider/augeas/augeas.rb b/lib/puppet/provider/augeas/augeas.rb
index 6c9102b..ed3404d 100644
--- a/lib/puppet/provider/augeas/augeas.rb
+++ b/lib/puppet/provider/augeas/augeas.rb
@@ -24,40 +24,39 @@ Puppet::Type.type(:augeas).provide(:augeas) do
   include Puppet::Util::Diff
   include Puppet::Util::Package
 
-  confine :feature => :augeas
+  confine feature: :augeas
 
-  has_features :parse_commands, :need_to_run?,:execute_changes
+  has_features :parse_commands, :need_to_run?, :execute_changes
 
-  SAVE_NOOP = "noop"
-  SAVE_OVERWRITE = "overwrite"
-  SAVE_NEWFILE = "newfile"
-  SAVE_BACKUP = "backup"
+  SAVE_NOOP = 'noop'.freeze
+  SAVE_OVERWRITE = 'overwrite'.freeze
+  SAVE_NEWFILE = 'newfile'.freeze
+  SAVE_BACKUP = 'backup'.freeze
 
   COMMANDS = {
-    "set" => [ :path, :string ],
-    "setm" => [ :path, :string, :string ],
-    "rm" => [ :path ],
-    "clear" => [ :path ],
-    "clearm" => [ :path, :string ],
-    "touch" => [ :path ],
-    "mv" => [ :path, :path ],
-    "rename" => [ :path, :string ],
-    "insert" => [ :string, :string, :path ],
-    "get" => [ :path, :comparator, :string ],
-    "values" => [ :path, :glob ],
-    "defvar" => [ :string, :path ],
-    "defnode" => [ :string, :path, :string ],
-    "match" => [ :path, :glob ],
-    "size" => [:comparator, :int],
-    "include" => [:string],
-    "not_include" => [:string],
-    "==" => [:glob],
-    "!=" => [:glob]
-  }
-
-  COMMANDS["ins"] = COMMANDS["insert"]
-  COMMANDS["remove"] = COMMANDS["rm"]
-  COMMANDS["move"] = COMMANDS["mv"]
+    'set' => [:path, :string],
+    'setm' => [:path, :string, :string],
+    'rm' => [:path],
+    'remove' => [:path],
+    'clear' => [:path],
+    'clearm' => [:path, :string],
+    'touch' => [:path],
+    'mv' => [:path, :path],
+    'move' => [:path, :path],
+    'rename' => [:path, :string],
+    'insert' => [:string, :string, :path],
+    'ins' => [:string, :string, :path],
+    'get' => [:path, :comparator, :string],
+    'values' => [:path, :glob],
+    'defvar' => [:string, :path],
+    'defnode' => [:string, :path, :string],
+    'match' => [:path, :glob],
+    'size' => [:comparator, :int],
+    'include' => [:string],
+    'not_include' => [:string],
+    '==' => [:glob],
+    '!=' => [:glob],
+  }.freeze
 
   attr_accessor :aug
 
@@ -70,11 +69,11 @@ Puppet::Type.type(:augeas).provide(:augeas) do
   def parse_commands(data)
     context = resource[:context]
     # Add a trailing / if it is not there
-    if (context.length > 0)
-      context << "/" if context[-1, 1] != "/"
+    unless context.empty?
+      context << '/' if context[-1, 1] != '/'
     end
 
-    data = data.split($/) if data.is_a?(String)
+    data = data.split($INPUT_RECORD_SEPARATOR) if data.is_a?(String)
     data = data.flatten
     args = []
     data.each do |line|
@@ -82,13 +81,13 @@ Puppet::Type.type(:augeas).provide(:augeas) do
       next if line.nil? || line.empty?
       argline = []
       sc = StringScanner.new(line)
-      cmd = sc.scan(/\w+|==|!=/)
+      cmd = sc.scan(%r{\w+|==|!=})
       formals = COMMANDS[cmd]
-      fail(_("Unknown command %{cmd}") % { cmd: cmd }) unless formals
+      fail(_('Unknown command %{cmd}') % { cmd: cmd }) unless formals
       argline << cmd
       narg = 0
       formals.each do |f|
-        sc.skip(/\s+/)
+        sc.skip(%r{\s+})
         narg += 1
         if f == :path
           start = sc.pos
@@ -96,53 +95,53 @@ Puppet::Type.type(:augeas).provide(:augeas) do
           inSingleTick = false
           inDoubleTick = false
           begin
-            sc.skip(/([^\]\[\s\\'"]|\\.)+/)
+            sc.skip(%r{([^\]\[\s\\'"]|\\.)+})
             ch = sc.getch
-            nbracket += 1 if ch == "["
-            nbracket -= 1 if ch == "]"
+            nbracket += 1 if ch == '['
+            nbracket -= 1 if ch == ']'
             inSingleTick = !inSingleTick if ch == "'"
-            inDoubleTick = !inDoubleTick if ch == "\""
-            fail(_("unmatched [")) if nbracket < 0
-          end until ((nbracket == 0 && !inSingleTick && !inDoubleTick && (ch =~ /\s/)) || sc.eos?)
-            len = sc.pos - start
-            len -= 1 unless sc.eos?
+            inDoubleTick = !inDoubleTick if ch == '"'
+            fail(_('unmatched [')) if nbracket < 0
+          end until ((nbracket == 0 && !inSingleTick && !inDoubleTick && (ch =~ %r{\s})) || sc.eos?)
+          len = sc.pos - start
+          len -= 1 unless sc.eos?
           unless p = sc.string[start, len]
-            fail(_("missing path argument %{narg} for %{cmd}") % { narg: narg, cmd: cmd })
+            fail(_('missing path argument %{narg} for %{cmd}') % { narg: narg, cmd: cmd })
           end
           # Rip off any ticks if they are there.
-          p = p[1, (p.size - 2)] if p[0,1] == "'" || p[0,1] == "\""
-          p.chomp!("/")
-          if p[0,1] != '$' && p[0,1] != "/"
-            argline << context + p
-          else
-            argline << p
-          end
+          p = p[1, (p.size - 2)] if p[0, 1] == "'" || p[0, 1] == '"'
+          p.chomp!('/')
+          argline << if p[0, 1] != '$' && p[0, 1] != '/'
+                       context + p
+                     else
+                       p
+                     end
         elsif f == :string
           delim = sc.peek(1)
-          if delim == "'" || delim == "\""
+          if delim == "'" || delim == '"'
             sc.getch
-            argline << sc.scan(/([^\\#{delim}]|(\\.))*/)
+            argline << sc.scan(%r{([^\\#{delim}]|(\\.))*})
             # Unescape the delimiter so it's actually possible to have a
             # literal delim inside the string. We only unescape the
             # delimeter and not every backslash-escaped character so that
             # things like escaped spaces '\ ' get passed through because
             # Augeas needs to see them. If we unescaped them, too, users
             # would be forced to double-escape them
-            argline.last.gsub!(/\\(#{delim})/, '\1')
+            argline.last.gsub!(%r{\\(#{delim})}, '\1')
             sc.getch
           else
-            argline << sc.scan(/[^\s]+/)
+            argline << sc.scan(%r{[^\s]+})
           end
-          fail(_("missing string argument %{narg} for %{cmd}") % { narg: narg, cmd: cmd }) unless argline[-1]
+          fail(_('missing string argument %{narg} for %{cmd}') % { narg: narg, cmd: cmd }) unless argline[-1]
         elsif f == :comparator
-          argline << sc.scan(/(==|!=|=~|<=|>=|<|>)/)
+          argline << sc.scan(%r{(==|!=|=~|<=|>=|<|>)})
           unless argline[-1]
             puts sc.rest
-            fail(_("invalid comparator for command %{cmd}") % { cmd: cmd })
+            fail(_('invalid comparator for command %{cmd}') % { cmd: cmd })
           end
         elsif f == :int
-          argline << sc.scan(/\d+/).to_i
-        elsif f== :glob
+          argline << sc.scan(%r{\d+}).to_i
+        elsif f == :glob
           argline << sc.rest
         end
       end
@@ -151,46 +150,45 @@ Puppet::Type.type(:augeas).provide(:augeas) do
     args
   end
 
-
   def open_augeas
     unless @aug
       flags = Augeas::NONE
       flags = Augeas::TYPE_CHECK if resource[:type_check] == :true
 
-      if resource[:incl]
-        flags |= Augeas::NO_MODL_AUTOLOAD
-      else
-        flags |= Augeas::NO_LOAD
-      end
+      flags |= if resource[:incl]
+                 Augeas::NO_MODL_AUTOLOAD
+               else
+                 Augeas::NO_LOAD
+               end
 
       root = resource[:root]
       load_path = get_load_path(resource)
       debug("Opening augeas with root #{root}, lens path #{load_path}, flags #{flags}")
-      @aug = Augeas::open(root, load_path,flags)
+      @aug = Augeas.open(root, load_path, flags)
 
-      debug("Augeas version #{get_augeas_version} is installed") if versioncmp(get_augeas_version, "0.3.6") >= 0
+      debug("Augeas version #{get_augeas_version} is installed") if versioncmp(get_augeas_version, '0.3.6') >= 0
 
       # Optimize loading if the context is given and it's a simple path,
       # requires the glob function from Augeas 0.8.2 or up
-      glob_avail = !aug.match("/augeas/version/pathx/functions/glob").empty?
+      glob_avail = !aug.match('/augeas/version/pathx/functions/glob').empty?
       opt_ctx = resource[:context].match("^/files/[^'\"\\[\\]]+$") if resource[:context]
 
       if resource[:incl]
-        aug.set("/augeas/load/Xfm/lens", resource[:lens])
-        aug.set("/augeas/load/Xfm/incl", resource[:incl])
-        restricted_metadata = "/augeas//error"
-      elsif glob_avail and opt_ctx
+        aug.set('/augeas/load/Xfm/lens', resource[:lens])
+        aug.set('/augeas/load/Xfm/incl', resource[:incl])
+        restricted_metadata = '/augeas//error'
+      elsif glob_avail && opt_ctx
         # Optimize loading if the context is given, requires the glob function
         # from Augeas 0.8.2 or up
         ctx_path = resource[:context].sub(/^\/files(.*?)\/?$/, '\1/')
         load_path = "/augeas/load/*['%s' !~ glob(incl) + regexp('/.*')]" % ctx_path
 
-        if aug.match(load_path).size < aug.match("/augeas/load/*").size
+        if aug.match(load_path).size < aug.match('/augeas/load/*').size
           aug.rm(load_path)
           restricted_metadata = "/augeas/files#{ctx_path}/error"
         else
           # This will occur if the context is less specific than any glob
-          debug("Unable to optimize files loaded by context path, no glob matches")
+          debug('Unable to optimize files loaded by context path, no glob matches')
         end
       end
       aug.load
@@ -202,7 +200,7 @@ Puppet::Type.type(:augeas).provide(:augeas) do
   def close_augeas
     if @aug
       @aug.close
-      debug("Closed the augeas connection")
+      debug('Closed the augeas connection')
       @aug = nil
     end
   end
@@ -212,7 +210,7 @@ Puppet::Type.type(:augeas).provide(:augeas) do
     when Integer
       true
     when String
-      s.match(/\A[+-]?\d+?(\.\d+)?\Z/n) == nil ? false : true
+      s.match(%r{\A[+-]?\d+?(\.\d+)?\Z}n).nil? ? false : true
     else
       false
     end
@@ -224,28 +222,28 @@ Puppet::Type.type(:augeas).provide(:augeas) do
   def process_get(cmd_array)
     return_value = false
 
-    #validate and tear apart the command
-    fail (_("Invalid command: %{cmd}") % { cmd: cmd_array.join(" ") }) if cmd_array.length < 4
+    # validate and tear apart the command
+    fail(_('Invalid command: %{cmd}') % { cmd: cmd_array.join(' ') }) if cmd_array.length < 4
     _ = cmd_array.shift
     path = cmd_array.shift
     comparator = cmd_array.shift
-    arg = cmd_array.join(" ")
+    arg = cmd_array.join(' ')
 
-    #check the value in augeas
+    # check the value in augeas
     result = @aug.get(path) || ''
 
-    if ['<', '<=', '>=', '>'].include? comparator and is_numeric?(result) and
-                                                      is_numeric?(arg)
+    if ['<', '<=', '>=', '>'].include?(comparator) && is_numeric?(result) &&
+       is_numeric?(arg)
       resultf = result.to_f
       argf = arg.to_f
-      return_value = (resultf.send(comparator, argf))
-    elsif comparator == "!="
+      return_value = resultf.send(comparator, argf)
+    elsif comparator == '!='
       return_value = (result != arg)
-    elsif comparator == "=~"
+    elsif comparator == '=~'
       regex = Regexp.new(arg)
       return_value = (result =~ regex)
     else
-      return_value = (result.send(comparator, arg))
+      return_value = result.send(comparator, arg)
     end
     !!return_value
   end
@@ -255,8 +253,8 @@ Puppet::Type.type(:augeas).provide(:augeas) do
   def process_values(cmd_array)
     return_value = false
 
-    #validate and tear apart the command
-    fail(_("Invalid command: %{cmd}") % { cmd: cmd_array.join(" ") }) if cmd_array.length < 3
+    # validate and tear apart the command
+    fail(_('Invalid command: %{cmd}') % { cmd: cmd_array.join(' ') }) if cmd_array.length < 3
     _ = cmd_array.shift
     path = cmd_array.shift
 
@@ -264,35 +262,35 @@ Puppet::Type.type(:augeas).provide(:augeas) do
     clause_array = parse_commands(cmd_array.shift)[0]
     verb = clause_array.shift
 
-    #Get the match paths from augeas
+    # Get the match paths from augeas
     result = @aug.match(path) || []
-    fail(_("Error trying to get path '%{path}'") % { path: path }) if (result == -1)
+    fail(_("Error trying to get path '%{path}'") % { path: path }) if result == -1
 
-    #Get the values of the match paths from augeas
-    values = result.collect{|r| @aug.get(r)}
+    # Get the values of the match paths from augeas
+    values = result.map { |r| @aug.get(r) }
 
     case verb
-    when "include"
+    when 'include'
       arg = clause_array.shift
       return_value = values.include?(arg)
-    when "not_include"
+    when 'not_include'
       arg = clause_array.shift
       return_value = !values.include?(arg)
-    when "=="
+    when '=='
       begin
         arg = clause_array.shift
         new_array = eval arg
         return_value = (values == new_array)
       rescue
-        fail(_("Invalid array in command: %{cmd}") % { cmd: cmd_array.join(" ") })
+        fail(_('Invalid array in command: %{cmd}') % { cmd: cmd_array.join(' ') })
       end
-    when "!="
+    when '!='
       begin
         arg = clause_array.shift
         new_array = eval arg
         return_value = (values != new_array)
       rescue
-        fail(_("Invalid array in command: %{cmd}") % { cmd: cmd_array.join(" ") })
+        fail(_('Invalid array in command: %{cmd}') % { cmd: cmd_array.join(' ') })
       end
     end
     !!return_value
@@ -303,8 +301,8 @@ Puppet::Type.type(:augeas).provide(:augeas) do
   def process_match(cmd_array)
     return_value = false
 
-    #validate and tear apart the command
-    fail(_("Invalid command: %{cmd}") % { cmd: cmd_array.join(" ") }) if cmd_array.length < 3
+    # validate and tear apart the command
+    fail(_('Invalid command: %{cmd}') % { cmd: cmd_array.join(' ') }) if cmd_array.length < 3
     _ = cmd_array.shift
     path = cmd_array.shift
 
@@ -312,43 +310,43 @@ Puppet::Type.type(:augeas).provide(:augeas) do
     clause_array = parse_commands(cmd_array.shift)[0]
     verb = clause_array.shift
 
-    #Get the values from augeas
+    # Get the values from augeas
     result = @aug.match(path) || []
-    fail(_("Error trying to match path '%{path}'") % { path: path }) if (result == -1)
+    fail(_("Error trying to match path '%{path}'") % { path: path }) if result == -1
 
     # Now do the work
     case verb
-    when "size"
-      fail(_("Invalid command: %{cmd}") % { cmd: cmd_array.join(" ") }) if clause_array.length != 2
+    when 'size'
+      fail(_('Invalid command: %{cmd}') % { cmd: cmd_array.join(' ') }) if clause_array.length != 2
       comparator = clause_array.shift
       arg = clause_array.shift
-      case comparator
-      when "!="
-        return_value = !(result.size.send(:==, arg))
-      else
-        return_value = (result.size.send(comparator, arg))
-      end
-    when "include"
+      return_value = case comparator
+                     when '!='
+                       !result.size.send(:==, arg)
+                     else
+                       result.size.send(comparator, arg)
+                     end
+    when 'include'
       arg = clause_array.shift
       return_value = result.include?(arg)
-    when "not_include"
+    when 'not_include'
       arg = clause_array.shift
       return_value = !result.include?(arg)
-    when "=="
+    when '=='
       begin
         arg = clause_array.shift
         new_array = eval arg
         return_value = (result == new_array)
       rescue
-        fail(_("Invalid array in command: %{cmd}") % { cmd: cmd_array.join(" ") })
+        fail(_('Invalid array in command: %{cmd}') % { cmd: cmd_array.join(' ') })
       end
-    when "!="
+    when '!='
       begin
         arg = clause_array.shift
         new_array = eval arg
         return_value = (result != new_array)
       rescue
-        fail(_("Invalid array in command: %{cmd}") % { cmd: cmd_array.join(" ") })
+        fail(_('Invalid array in command: %{cmd}') % { cmd: cmd_array.join(' ') })
       end
     end
     !!return_value
@@ -361,7 +359,7 @@ Puppet::Type.type(:augeas).provide(:augeas) do
     # Permits colon separated strings or arrays
     if resource[:load_path]
       load_path = [resource[:load_path]].flatten
-      load_path.map! { |path| path.split(/:/) }
+      load_path.map! { |path| path.split(%r{:}) }
       load_path.flatten!
     end
 
@@ -369,24 +367,24 @@ Puppet::Type.type(:augeas).provide(:augeas) do
       load_path << "#{Puppet[:libdir]}/augeas/lenses"
     end
 
-    load_path.join(":")
+    load_path.join(':')
   end
 
   def get_augeas_version
-    @aug.get("/augeas/version") || ""
+    @aug.get('/augeas/version') || ''
   end
 
   def set_augeas_save_mode(mode)
-    @aug.set("/augeas/save", mode)
+    @aug.set('/augeas/save', mode)
   end
 
   def print_load_errors(path)
-    errors = @aug.match("/augeas//error")
+    errors = @aug.match('/augeas//error')
     unless errors.empty?
       if path && !@aug.match(path).empty?
-        warning(_("Loading failed for one or more files, see debug for /augeas//error output"))
+        warning(_('Loading failed for one or more files, see debug for /augeas//error output'))
       else
-        debug("Loading failed for one or more files, output from /augeas//error:")
+        debug('Loading failed for one or more files, output from /augeas//error:')
       end
     end
     print_errors(errors)
@@ -394,7 +392,7 @@ Puppet::Type.type(:augeas).provide(:augeas) do
 
   def print_put_errors
     errors = @aug.match("/augeas//error[. = 'put_failed']")
-    debug("Put failed on one or more files, output from /augeas//error:") unless errors.empty?
+    debug('Put failed on one or more files, output from /augeas//error:') unless errors.empty?
     print_errors(errors)
   end
 
@@ -416,14 +414,14 @@ Puppet::Type.type(:augeas).provide(:augeas) do
     begin
       open_augeas
       filter = resource[:onlyif]
-      unless filter == ""
+      unless filter == ''
         cmd_array = parse_commands(filter)[0]
-        command = cmd_array[0];
+        command = cmd_array[0]
         begin
           case command
-          when "get"; return_value = process_get(cmd_array)
-          when "values"; return_value = process_values(cmd_array)
-          when "match"; return_value = process_match(cmd_array)
+          when 'get' then return_value = process_get(cmd_array)
+          when 'values' then return_value = process_values(cmd_array)
+          when 'match' then return_value = process_match(cmd_array)
           end
         rescue StandardError => e
           fail(_("Error sending command '%{command}' with params %{param}/%{message}") % { command: command, param: cmd_array[1..-1].inspect, message: e.message })
@@ -433,37 +431,37 @@ Puppet::Type.type(:augeas).provide(:augeas) do
       unless force
         # If we have a version of augeas which is at least 0.3.6 then we
         # can make the changes now and see if changes were made.
-        if return_value and versioncmp(get_augeas_version, "0.3.6") >= 0
-          debug("Will attempt to save and only run if files changed")
+        if return_value && versioncmp(get_augeas_version, '0.3.6') >= 0
+          debug('Will attempt to save and only run if files changed')
           # Execute in NEWFILE mode so we can show a diff
           set_augeas_save_mode(SAVE_NEWFILE)
           do_execute_changes
           save_result = @aug.save
           unless save_result
             print_put_errors
-            fail(_("Saving failed, see debug"))
+            fail(_('Saving failed, see debug'))
           end
 
-          saved_files = @aug.match("/augeas/events/saved")
-          if saved_files.size > 0
-            root = resource[:root].sub(/^\/$/, "")
-            saved_files.map! {|key| @aug.get(key).sub(/^\/files/, root) }
+          saved_files = @aug.match('/augeas/events/saved')
+          if !saved_files.empty?
+            root = resource[:root].sub(/^\/$/, '')
+            saved_files.map! { |key| @aug.get(key).sub(/^\/files/, root) }
             saved_files.uniq.each do |saved_file|
               if Puppet[:show_diff] && @resource[:show_diff]
-                self.send(@resource[:loglevel], "\n" + diff(saved_file, saved_file + ".augnew"))
+                send(@resource[:loglevel], "\n" + diff(saved_file, saved_file + '.augnew'))
               end
-              File.delete(saved_file + ".augnew")
+              File.delete(saved_file + '.augnew')
             end
-            debug("Files changed, should execute")
+            debug('Files changed, should execute')
             return_value = true
           else
-            debug("Skipping because no files were changed")
+            debug('Skipping because no files were changed')
             return_value = false
           end
         end
       end
     ensure
-      if not return_value or resource.noop? or not save_result
+      if !return_value || resource.noop? || !save_result
         close_augeas
       end
     end
@@ -473,17 +471,17 @@ Puppet::Type.type(:augeas).provide(:augeas) do
   def execute_changes
     # Workaround Augeas bug where changing the save mode doesn't trigger a
     # reload of the previously saved file(s) when we call Augeas#load
-    @aug.match("/augeas/events/saved").each do |file|
+    @aug.match('/augeas/events/saved').each do |file|
       @aug.rm("/augeas#{@aug.get(file)}/mtime")
     end
 
     # Reload augeas, and execute the changes for real
-    set_augeas_save_mode(SAVE_OVERWRITE) if versioncmp(get_augeas_version, "0.3.6") >= 0
+    set_augeas_save_mode(SAVE_OVERWRITE) if versioncmp(get_augeas_version, '0.3.6') >= 0
     @aug.load
     do_execute_changes
     unless @aug.save
       print_put_errors
-      fail(_("Save failed, see debug"))
+      fail(_('Save failed, see debug'))
     end
 
     :executed
@@ -495,75 +493,75 @@ Puppet::Type.type(:augeas).provide(:augeas) do
   def do_execute_changes
     commands = parse_commands(resource[:changes])
     commands.each do |cmd_array|
-      fail(_("invalid command %{cmd}") % { value0: cmd_array.join[" "] }) if cmd_array.length < 2
+      fail(_('invalid command %{cmd}') % { value0: cmd_array.join[' '] }) if cmd_array.length < 2
       command = cmd_array[0]
       cmd_array.shift
       begin
         case command
-          when "set"
-            debug("sending command '#{command}' with params #{cmd_array.inspect}")
-            rv = aug.set(cmd_array[0], cmd_array[1])
-            fail(_("Error sending command '%{command}' with params %{params}") % { command: command, params: cmd_array.inspect }) if (!rv)
-          when "setm"
-            if aug.respond_to?(command)
-              debug("sending command '#{command}' with params #{cmd_array.inspect}")
-              rv = aug.setm(cmd_array[0], cmd_array[1], cmd_array[2])
-              fail(_("Error sending command '%{command}' with params %{params}") % { command: command, params: cmd_array.inspect }) if (rv == -1)
-            else
-              fail(_("command '%{command}' not supported in installed version of ruby-augeas") % { command: command })
-            end
-          when "rm", "remove"
+        when 'set'
+          debug("sending command '#{command}' with params #{cmd_array.inspect}")
+          rv = aug.set(cmd_array[0], cmd_array[1])
+          fail(_("Error sending command '%{command}' with params %{params}") % { command: command, params: cmd_array.inspect }) unless rv
+        when 'setm'
+          if aug.respond_to?(command)
             debug("sending command '#{command}' with params #{cmd_array.inspect}")
-            rv = aug.rm(cmd_array[0])
-            fail(_("Error sending command '%{command}' with params %{params}") % { command: command, params: cmd_array.inspect }) if (rv == -1)
-          when "clear"
+            rv = aug.setm(cmd_array[0], cmd_array[1], cmd_array[2])
+            fail(_("Error sending command '%{command}' with params %{params}") % { command: command, params: cmd_array.inspect }) if rv == -1
+          else
+            fail(_("command '%{command}' not supported in installed version of ruby-augeas") % { command: command })
+          end
+        when 'rm', 'remove'
+          debug("sending command '#{command}' with params #{cmd_array.inspect}")
+          rv = aug.rm(cmd_array[0])
+          fail(_("Error sending command '%{command}' with params %{params}") % { command: command, params: cmd_array.inspect }) if rv == -1
+        when 'clear'
+          debug("sending command '#{command}' with params #{cmd_array.inspect}")
+          rv = aug.clear(cmd_array[0])
+          fail(_("Error sending command '%{command}' with params %{params}") % { command: command, params: cmd_array.inspect }) unless rv
+        when 'clearm'
+          # Check command exists ... doesn't currently in ruby-augeas 0.4.1
+          if aug.respond_to?(command)
             debug("sending command '#{command}' with params #{cmd_array.inspect}")
+            rv = aug.clearm(cmd_array[0], cmd_array[1])
+            fail(_("Error sending command '%{command}' with params %{params}") % { command: command, params: cmd_array.inspect }) unless rv
+          else
+            fail(_("command '%{command}' not supported in installed version of ruby-augeas") % { command: command })
+          end
+        when 'touch'
+          debug("sending command '#{command}' (match, set) with params #{cmd_array.inspect}")
+          if aug.match(cmd_array[0]).empty?
             rv = aug.clear(cmd_array[0])
-            fail(_("Error sending command '%{command}' with params %{params}") % { command: command, params: cmd_array.inspect }) if (!rv)
-          when "clearm"
-            # Check command exists ... doesn't currently in ruby-augeas 0.4.1
-            if aug.respond_to?(command)
-              debug("sending command '#{command}' with params #{cmd_array.inspect}")
-              rv = aug.clearm(cmd_array[0], cmd_array[1])
-              fail(_("Error sending command '%{command}' with params %{params}") % { command: command, params: cmd_array.inspect }) if (!rv)
-            else
-              fail(_("command '%{command}' not supported in installed version of ruby-augeas") % { command: command })
-            end
-          when "touch"
-            debug("sending command '#{command}' (match, set) with params #{cmd_array.inspect}")
-            if aug.match(cmd_array[0]).empty?
-              rv = aug.clear(cmd_array[0])
-              fail(_("Error sending command '%{command}' with params %{params}") % { command: command, params: cmd_array.inspect }) if (!rv)
-            end
-          when "insert", "ins"
-            label = cmd_array[0]
-            where = cmd_array[1]
-            path = cmd_array[2]
-            case where
-              when "before"; before = true
-              when "after"; before = false
-              else fail(_("Invalid value '%{where}' for where param") % { where: where })
-            end
-            debug("sending command '#{command}' with params #{[label, where, path].inspect}")
-            rv = aug.insert(path, label, before)
-            fail(_("Error sending command '%{command}' with params %{params}") % { command: command, params: cmd_array.inspect }) if (rv == -1)
-          when "defvar"
-            debug("sending command '#{command}' with params #{cmd_array.inspect}")
-            rv = aug.defvar(cmd_array[0], cmd_array[1])
-            fail(_("Error sending command '%{command}' with params %{params}") % { command: command, params: cmd_array.inspect }) if (!rv)
-          when "defnode"
-            debug("sending command '#{command}' with params #{cmd_array.inspect}")
-            rv = aug.defnode(cmd_array[0], cmd_array[1], cmd_array[2])
-            fail(_("Error sending command '%{command}' with params %{params}") % { command: command, params: cmd_array.inspect }) if (!rv)
-          when "mv", "move"
-            debug("sending command '#{command}' with params #{cmd_array.inspect}")
-            rv = aug.mv(cmd_array[0], cmd_array[1])
-            fail(_("Error sending command '%{command}' with params %{params}") % { command: command, params: cmd_array.inspect }) if (rv == -1)
-          when "rename"
-            debug("sending command '#{command}' with params #{cmd_array.inspect}")
-            rv = aug.rename(cmd_array[0], cmd_array[1])
-            fail(_("Error sending command '%{command}' with params %{params}") % { command: command, params: cmd_array.inspect }) if (rv == -1)
-          else fail(_("Command '%{command}' is not supported") % { command: command })
+            fail(_("Error sending command '%{command}' with params %{params}") % { command: command, params: cmd_array.inspect }) unless rv
+          end
+        when 'insert', 'ins'
+          label = cmd_array[0]
+          where = cmd_array[1]
+          path = cmd_array[2]
+          case where
+          when 'before' then before = true
+          when 'after' then before = false
+          else fail(_("Invalid value '%{where}' for where param") % { where: where })
+          end
+          debug("sending command '#{command}' with params #{[label, where, path].inspect}")
+          rv = aug.insert(path, label, before)
+          fail(_("Error sending command '%{command}' with params %{params}") % { command: command, params: cmd_array.inspect }) if rv == -1
+        when 'defvar'
+          debug("sending command '#{command}' with params #{cmd_array.inspect}")
+          rv = aug.defvar(cmd_array[0], cmd_array[1])
+          fail(_("Error sending command '%{command}' with params %{params}") % { command: command, params: cmd_array.inspect }) unless rv
+        when 'defnode'
+          debug("sending command '#{command}' with params #{cmd_array.inspect}")
+          rv = aug.defnode(cmd_array[0], cmd_array[1], cmd_array[2])
+          fail(_("Error sending command '%{command}' with params %{params}") % { command: command, params: cmd_array.inspect }) unless rv
+        when 'mv', 'move'
+          debug("sending command '#{command}' with params #{cmd_array.inspect}")
+          rv = aug.mv(cmd_array[0], cmd_array[1])
+          fail(_("Error sending command '%{command}' with params %{params}") % { command: command, params: cmd_array.inspect }) if rv == -1
+        when 'rename'
+          debug("sending command '#{command}' with params #{cmd_array.inspect}")
+          rv = aug.rename(cmd_array[0], cmd_array[1])
+          fail(_("Error sending command '%{command}' with params %{params}") % { command: command, params: cmd_array.inspect }) if rv == -1
+        else fail(_("Command '%{command}' is not supported") % { command: command })
         end
       rescue StandardError => e
         fail(_("Error sending command '%{command}' with params %{params}/%{message}") % { command: command, params: cmd_array.inspect, message: e.message })