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.

3 files changed, 226 insertions, 231 deletions

diff --git a/lib/puppet/feature/augeas.rb b/lib/puppet/feature/augeas.rb
index e22f53b..2e26fbf 100644
--- a/lib/puppet/feature/augeas.rb
+++ b/lib/puppet/feature/augeas.rb
@@ -1,3 +1,3 @@
 require 'puppet/util/feature'
 
-Puppet.features.add(:augeas, :libs => ["augeas"])
+Puppet.features.add(:augeas, libs: ['augeas'])
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 })
diff --git a/lib/puppet/type/augeas.rb b/lib/puppet/type/augeas.rb
index 49be7b9..fdde4b8 100644
--- a/lib/puppet/type/augeas.rb
+++ b/lib/puppet/type/augeas.rb
@@ -18,9 +18,9 @@ require 'puppet/parameter/boolean'
 Puppet::Type.newtype(:augeas) do
   include Puppet::Util
 
-  feature :parse_commands, "Parse the command string"
-  feature :need_to_run?, "If the command should run"
-  feature :execute_changes, "Actually make the changes"
+  feature :parse_commands, 'Parse the command string'
+  feature :need_to_run?, 'If the command should run'
+  feature :execute_changes, 'Actually make the changes'
 
   @doc = <<-'EOT'
     Apply a change or an array of changes to the filesystem
@@ -53,7 +53,7 @@ Puppet::Type.newtype(:augeas) do
   EOT
 
   newparam (:name) do
-    desc "The name of this task. Used for uniqueness."
+    desc 'The name of this task. Used for uniqueness.'
     isnamevar
   end
 
@@ -61,10 +61,10 @@ Puppet::Type.newtype(:augeas) do
     desc "Optional context path. This value is prepended to the paths of all
       changes if the path is relative. If the `incl` parameter is set,
       defaults to `/files + incl`; otherwise, defaults to the empty string."
-    defaultto ""
+    defaultto ''
     munge do |value|
-      if value.empty? and resource[:incl]
-        "/files" + resource[:incl]
+      if value.empty? && resource[:incl]
+        '/files' + resource[:incl]
       else
         value
       end
@@ -98,10 +98,9 @@ Puppet::Type.newtype(:augeas) do
       * `STRING` is a string
       * `INT` is a number
       * `AN_ARRAY` is in the form `['a string', 'another']`"
-    defaultto ""
+    defaultto ''
   end
 
-
   newparam(:changes) do
     desc "The changes which should be applied to the filesystem. This
     can be a command or an array of commands. The following commands are supported:
@@ -124,15 +123,14 @@ Puppet::Type.newtype(:augeas) do
     If the `context` parameter is set, that value is prepended to any relative `PATH`s."
   end
 
-
   newparam(:root) do
-    desc "A file system path; all files loaded by Augeas are loaded underneath `root`."
-    defaultto "/"
+    desc 'A file system path; all files loaded by Augeas are loaded underneath `root`.'
+    defaultto '/'
   end
 
   newparam(:load_path) do
     desc "Optional colon-separated list or array of directories; these directories are searched for schema definitions. The agent's `$libdir/augeas/lenses` path will always be added to support pluginsync."
-    defaultto ""
+    defaultto ''
   end
 
   newparam(:force) do
@@ -143,7 +141,7 @@ Puppet::Type.newtype(:augeas) do
   end
 
   newparam(:type_check) do
-    desc "Whether augeas should perform typechecking. Defaults to false."
+    desc 'Whether augeas should perform typechecking. Defaults to false.'
     newvalues(:true, :false)
 
     defaultto :false
@@ -164,10 +162,10 @@ Puppet::Type.newtype(:augeas) do
   validate do
     has_lens = !self[:lens].nil?
     has_incl = !self[:incl].nil?
-    self.fail _("You must specify both the lens and incl parameters, or neither.") if has_lens != has_incl
+    fail(_('You must specify both the lens and incl parameters, or neither.')) if has_lens != has_incl
   end
 
-  newparam(:show_diff, :boolean => true, :parent => Puppet::Parameter::Boolean) do
+  newparam(:show_diff, boolean: true, parent: Puppet::Parameter::Boolean) do
     desc "Whether to display differences when the file changes, defaulting to
         true.  This parameter is useful for files that may contain passwords or
         other secret data, which might otherwise be included in Puppet reports or
@@ -180,22 +178,22 @@ Puppet::Type.newtype(:augeas) do
   # This is the actual meat of the code. It forces
   # augeas to be run and fails or not based on the augeas return
   # code.
-  newproperty(:returns) do |property|
+  newproperty(:returns) do |_property|
     include Puppet::Util
-    desc "The expected return code from the augeas command. Should not be set."
+    desc 'The expected return code from the augeas command. Should not be set.'
 
     defaultto 0
 
     # Make output a bit prettier
-    def change_to_s(currentvalue, newvalue)
-      _("executed successfully")
+    def change_to_s(_currentvalue, _newvalue)
+      _('executed successfully')
     end
 
     # if the onlyif resource is provided, then the value is parsed.
     # a return value of 0 will stop execution because it matches the
     # default value.
     def retrieve
-      if @resource.provider.need_to_run?()
+      if @resource.provider.need_to_run?
         :need_to_run
       else
         0
@@ -207,5 +205,4 @@ Puppet::Type.newtype(:augeas) do
       @resource.provider.execute_changes
     end
   end
-
 end