puppet 0.24.9 → 0.25.0

data/lib/puppet/property/list.rb

@@ -65,10 +65,10 @@ module Puppet
             end
 
             def prepare_is_for_comparison(is)
-                if is.is_a? Array
-                    is = dearrayify(is)
+                if is == :absent
+                    is = []
                 end
-                is
+                dearrayify(is)
             end
 
             def insync?(is)

data/lib/puppet/provider.rb

@@ -31,7 +31,7 @@ class Puppet::Provider
     # LAK 2007-05-09: Keep the model stuff around for backward compatibility
     attr_reader :model
     attr_accessor :resource
-    
+
     def self.command(name)
         name = symbolize(name)
 
@@ -91,8 +91,8 @@ class Puppet::Provider
         end
     end
 
-    def self.defaultnum
-        @defaults.length
+    def self.specificity
+        (@defaults.length * 100) + ancestors.select { |a| a.is_a? Class }.length
     end
 
     def self.initvars
@@ -123,7 +123,7 @@ class Puppet::Provider
                 # will catch it, if so.
                 return execute(cmd)
             end
-            
+
             # And then define an instance method that just calls the class method.
             # We need both, so both instances and classes can easily run the commands.
             unless method_defined? name
@@ -260,7 +260,7 @@ class Puppet::Provider
             # use the hash here for later events.
             @property_hash = resource
         elsif resource
-            @resource = resource if resource
+            @resource = resource
             # LAK 2007-05-09: Keep the model stuff around for backward compatibility
             @model = resource
             @property_hash = {}

data/lib/puppet/provider/augeas/augeas.rb

@@ -39,12 +39,12 @@ Puppet::Type.type(:augeas).provide(:augeas) do
       "match" => [ :path, :glob ],
       "size" => [:comparator, :int],
       "include" => [:string],
-      "eq" => [:glob],
-      "noteq" => [:glob]
+      "==" => [:glob],
+      "!=" => [:glob]
     }
 
     COMMANDS["ins"] = COMMANDS["insert"]
-    COMMANDS["remove"] = COMMANDS["rm"]    
+    COMMANDS["remove"] = COMMANDS["rm"]
 
     attr_accessor :aug
 
@@ -62,15 +62,15 @@ Puppet::Type.type(:augeas).provide(:augeas) do
         end
 
         if data.is_a?(String)
-            s = data
-            data = []
-            s.each_line { |line| data << line }
+            data = data.split($/)
         end
         args = []
         data.each do |line|
+            line.strip!
+            next if line.nil? || line.empty?
             argline = []
             sc = StringScanner.new(line)
-            cmd = sc.scan(/\w+/)
+            cmd = sc.scan(/\w+|==|!=/)
             formals = COMMANDS[cmd]
             fail("Unknown command #{cmd}") unless formals
             argline << cmd
@@ -82,7 +82,7 @@ Puppet::Type.type(:augeas).provide(:augeas) do
                     start = sc.pos
                     nbracket = 0
                     begin
-                        sc.skip(/[^\]\[\s]+/)
+                        sc.skip(/([^\]\[\s\\]|\\.)+/)
                         ch = sc.getch
                         nbracket += 1 if ch == "["
                         nbracket -= 1 if ch == "]"
@@ -93,6 +93,7 @@ Puppet::Type.type(:augeas).provide(:augeas) do
                     unless p = sc.string[start, len]
                         fail("missing path argument #{narg} for #{cmd}")
                     end
+                    p.chomp!("/")
                     if p[0,1] != "$" && p[0,1] != "/"
                         argline << context + p
                     else
@@ -108,18 +109,18 @@ Puppet::Type.type(:augeas).provide(:augeas) do
                         argline << sc.scan(/[^\s]+/)
                     end
                     unless argline[-1]
-                        fail(raise Exception, "missing string argument #{narg} for #{cmd}")
+                        fail("missing string argument #{narg} for #{cmd}")
                     end
                 elsif f == :comparator
                     argline << sc.scan(/(==|!=|=~|<|<=|>|>=)/)
                     unless argline[-1]
-                        puts sc.rest() 
-                        fail(raise Exception, "invalid comparator for command #{cmd}")
+                        puts sc.rest
+                        fail("invalid comparator for command #{cmd}")
                     end
                 elsif f == :int
                     argline << sc.scan(/\d+/).to_i
                 elsif f== :glob
-                    argline << sc.rest()
+                    argline << sc.rest
                 end
             end
             args << argline
@@ -129,26 +130,26 @@ Puppet::Type.type(:augeas).provide(:augeas) do
 
 
     def open_augeas
-        if (@aug.nil?)
-            flags = 0
-            (flags = 1 << 2 ) if self.resource[:type_check] == :true
-            root = self.resource[:root]
-            load_path = self.resource[:load_path]
+        unless @aug
+            flags = Augeas::NONE
+            flags = Augeas::TYPE_CHECK if resource[:type_check] == :true
+            root = resource[:root]
+            load_path = resource[:load_path]
             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)
 
-            if (self.get_augeas_version() >= "0.3.6")
-                debug("Augeas version #{self.get_augeas_version()} is installed")
+            if get_augeas_version >= "0.3.6"
+                debug("Augeas version #{get_augeas_version} is installed")
             end
         end
         @aug
     end
 
     def close_augeas
-        if (!@aug.nil?)
-            @aug.close()
+        if @aug
+            @aug.close
             debug("Closed the augeas connection")
-            @aug = nil;
+            @aug = nil
         end
     end
 
@@ -160,26 +161,23 @@ Puppet::Type.type(:augeas).provide(:augeas) do
 
         #validate and tear apart the command
         fail ("Invalid command: #{cmd_array.join(" ")}") if cmd_array.length < 4
-        cmd = cmd_array.shift()
-        path = cmd_array.shift()
-        comparator = cmd_array.shift()
+        cmd = cmd_array.shift
+        path = cmd_array.shift
+        comparator = cmd_array.shift
         arg = cmd_array.join(" ")
 
         #check the value in augeas
         result = @aug.get(path) || ''
-        unless result.nil?
-            case comparator
-                when "!=":
-                    return_value = true if !(result == arg)
-                when "=~":
-                    regex = Regexp.new(arg)
-                    loc = result=~ regex
-                    return_value = true if ! loc.nil?
-                else
-                    return_value = true if (result.send(comparator, arg))
-            end
+        case comparator
+        when "!="
+            return_value = (result != arg)
+        when "=~"
+            regex = Regexp.new(arg)
+            return_value = (result =~ regex)
+        else
+            return_value = (result.send(comparator, arg))
         end
-        return_value
+        return !!return_value
     end
 
     # Used by the need_to_run? method to process match filters. Returns
@@ -189,45 +187,43 @@ Puppet::Type.type(:augeas).provide(:augeas) do
 
         #validate and tear apart the command
         fail("Invalid command: #{cmd_array.join(" ")}") if cmd_array.length < 3
-        cmd = cmd_array.shift()
-        path = cmd_array.shift()
+        cmd = cmd_array.shift
+        path = cmd_array.shift
 
         # Need to break apart the clause
-        clause_array = parse_commands(cmd_array.shift())[0]
-        verb = clause_array.shift()
+        clause_array = parse_commands(cmd_array.shift)[0]
+        verb = clause_array.shift
 
         #Get the values from augeas
-        result = @aug.match(path) || ''
+        result = @aug.match(path) || []
         # Now do the work
-        unless (result.nil?)
-            case verb
-                when "size":
-                    fail("Invalid command: #{cmd_array.join(" ")}") if clause_array.length != 2
-                    comparator = clause_array.shift()
-                    arg = clause_array.shift()
-                    return_value = true if (result.size.send(comparator, arg))
-                when "include":
-                    arg = clause_array.shift()
-                    return_value = true if result.include?(arg)
-                when "eq":
-                    begin
-                        arg = clause_array.shift()
-                        new_array = eval arg
-                        return_value = true if result == new_array
-                    rescue
-                        fail("Invalid array in command: #{cmd_array.join(" ")}")
-                    end
-                when "noteq":
-                    begin
-                        arg = clause_array.shift()
-                        new_array = eval arg
-                        return_value = true if result != new_array
-                    rescue
-                        fail("Invalid array in command: #{cmd_array.join(" ")}")
-                    end                    
+        case verb
+        when "size"
+            fail("Invalid command: #{cmd_array.join(" ")}") if clause_array.length != 2
+            comparator = clause_array.shift
+            arg = clause_array.shift
+            return_value = (result.size.send(comparator, arg))
+        when "include"
+            arg = clause_array.shift
+            return_value = result.include?(arg)
+        when "=="
+            begin
+                arg = clause_array.shift
+                new_array = eval arg
+                return_value = (result == new_array)
+            rescue
+                fail("Invalid array in command: #{cmd_array.join(" ")}")
+            end
+        when "!="
+            begin
+                arg = clause_array.shift
+                new_array = eval arg
+                return_value = (result != new_array)
+            rescue
+                fail("Invalid array in command: #{cmd_array.join(" ")}")
             end
         end
-        return_value
+        return !!return_value
     end
 
     def get_augeas_version
@@ -240,64 +236,70 @@ Puppet::Type.type(:augeas).provide(:augeas) do
 
     def files_changed?
         saved_files = @aug.match("/augeas/events/saved")
-        return saved_files.size() > 0
+        return saved_files.size > 0
     end
 
     # Determines if augeas acutally needs to run.
     def need_to_run?
         force = resource[:force]
         return_value = true
-        self.open_augeas()
-        filter = resource[:onlyif]
-        unless (filter == "")
-            cmd_array = parse_commands(filter)[0]
-            command = cmd_array[0];
-            begin
-                case command
-                    when "get" then return_value = process_get(cmd_array)
-                    when "match" then return_value = process_match(cmd_array)
+        begin
+            open_augeas
+            filter = resource[:onlyif]
+            unless filter == ""
+                cmd_array = parse_commands(filter)[0]
+                command = cmd_array[0];
+                begin
+                    case command
+                    when "get"; return_value = process_get(cmd_array)
+                    when "match"; return_value = process_match(cmd_array)
+                    end
+                rescue Exception => e
+                    fail("Error sending command '#{command}' with params #{cmd_array[1..-1].inspect}/#{e.message}")
                 end
-            rescue Exception => e
-                fail("Error sending command '#{command}' with params #{cmd_array[1..-1].inspect}/#{e.message}")
             end
-        end
 
-        unless (force)
-            # If we have a verison of augeas which is at least 0.3.6 then we
-            # can make the changes now, see if changes were made, and
-            # actually do the save.
-            if ((return_value) and (self.get_augeas_version() >= "0.3.6"))
-                debug("Will attempt to save and only run if files changed")
-                self.set_augeas_save_mode(SAVE_NOOP)
-                self.do_execute_changes()
-                save_result = @aug.save()
-                saved_files = @aug.match("/augeas/events/saved")
-                if ((save_result) and (not files_changed?))
-                    debug("Skipping becuase no files were changed")
-                    return_value = false
-                else
-                    debug("Files changed, should execute")
+            unless force
+                # If we have a verison of augeas which is at least 0.3.6 then we
+                # can make the changes now, see if changes were made, and
+                # actually do the save.
+                if return_value and get_augeas_version >= "0.3.6"
+                    debug("Will attempt to save and only run if files changed")
+                    set_augeas_save_mode(SAVE_NOOP)
+                    do_execute_changes
+                    save_result = @aug.save
+                    saved_files = @aug.match("/augeas/events/saved")
+                    if save_result and not files_changed?
+                        debug("Skipping becuase no files were changed")
+                        return_value = false
+                    else
+                        debug("Files changed, should execute")
+                    end
                 end
             end
+        ensure
+            close_augeas
         end
-        self.close_augeas()
         return return_value
     end
 
     def execute_changes
         # Re-connect to augeas, and re-execute the changes
-        self.open_augeas()
-        if (self.get_augeas_version() >= "0.3.6")
-            self.set_augeas_save_mode(SAVE_OVERWRITE)
-        end
+        begin
+            open_augeas
+            if get_augeas_version >= "0.3.6"
+                set_augeas_save_mode(SAVE_OVERWRITE)
+            end
 
-        self.do_execute_changes()
+            do_execute_changes
 
-        success = @aug.save()
-        if (success != true)
-            fail("Save failed with return code #{success}")
+            success = @aug.save
+            if success != true
+                fail("Save failed with return code #{success}")
+            end
+        ensure
+            close_augeas
         end
-        self.close_augeas()
 
         return :executed
     end
@@ -308,16 +310,16 @@ Puppet::Type.type(:augeas).provide(:augeas) do
         commands.each do |cmd_array|
             fail("invalid command #{cmd_array.join[" "]}") if cmd_array.length < 2
             command = cmd_array[0]
-            cmd_array.shift()
+            cmd_array.shift
             begin
                 case command
-                    when "set":
+                    when "set"
                         debug("sending command '#{command}' with params #{cmd_array.inspect}")
-                        @aug.set(cmd_array[0], cmd_array[1])
-                    when "rm", "remove":
+                        aug.set(cmd_array[0], cmd_array[1])
+                    when "rm", "remove"
                         debug("sending command '#{command}' with params #{cmd_array.inspect}")
-                        @aug.rm(cmd_array[0])
-                    when "clear":
+                        aug.rm(cmd_array[0])
+                    when "clear"
                         debug("sending command '#{command}' with params #{cmd_array.inspect}")
                         @aug.clear(cmd_array[0])
                     when "insert", "ins"
@@ -325,11 +327,11 @@ Puppet::Type.type(:augeas).provide(:augeas) do
                         where = cmd_array[1]
                         path = cmd_array[2]
                         case where
-                            when "before": before = true
-                            when "after": before = false
+                            when "before"; before = true
+                            when "after"; before = false
                             else fail("Invalid value '#{where}' for where param")
                         end
-                        debug("sending command '#{command}' with params #{[label, where, path].inspect()}")
+                        debug("sending command '#{command}' with params #{[label, where, path].inspect}")
                         aug.insert(path, label, before)
                     else fail("Command '#{command}' is not supported")
                 end
@@ -338,5 +340,4 @@ Puppet::Type.type(:augeas).provide(:augeas) do
             end
         end
     end
-
 end

data/lib/puppet/provider/computer/computer.rb

@@ -5,10 +5,10 @@ Puppet::Type.type(:computer).provide :directoryservice, :parent => Puppet::Provi
     Note that these are distinctly different kinds of objects to 'hosts',
     as they require a MAC address and can have all sorts of policy attached to
     them.
-    
+
     This provider only manages Computer objects in the local directory service
     domain, not in remote directories.
-    
+
     If you wish to manage /etc/hosts on Mac OS X, then simply use the host
     type as per other platforms.
 
@@ -16,7 +16,7 @@ Puppet::Type.type(:computer).provide :directoryservice, :parent => Puppet::Provi
 
     confine :operatingsystem => :darwin
     defaultfor :operatingsystem => :darwin
-    
+
     # hurray for abstraction. The nameservice directoryservice provider can
     # handle everything we need. super.
 end

data/lib/puppet/provider/confine/variable.rb

@@ -57,6 +57,6 @@ class Puppet::Provider::Confine::Variable < Puppet::Provider::Confine
     end
 
     def test_value
-        setting? ? Puppet.settings[name] : facter_value 
+        setting? ? Puppet.settings[name] : facter_value
     end
 end