From df20c08345fba0b43833eef47c4da2fdd78523e9 Mon Sep 17 00:00:00 2001 From: Josh Cooper Date: Wed, 27 Jun 2018 22:57:38 -0700 Subject: 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. --- lib/puppet/provider/augeas/augeas.rb | 414 +++++++++++++++++------------------ 1 file changed, 206 insertions(+), 208 deletions(-) (limited to 'lib/puppet/provider/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 }) -- cgit v1.2.3