puppet 0.25.5 → 2.6.0

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

@@ -1,22 +1,22 @@
 require 'puppet/provider/nameservice/directoryservice'
 
 Puppet::Type.type(:computer).provide :directoryservice, :parent => Puppet::Provider::NameService::DirectoryService do
-    desc "Computer object management using DirectoryService on OS X.
-    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.
+  desc "Computer object management using DirectoryService on OS X.
+  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.
+  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.
+  If you wish to manage /etc/hosts on Mac OS X, then simply use the host
+  type as per other platforms.
 
-    "
+  "
 
-    confine :operatingsystem => :darwin
-    defaultfor :operatingsystem => :darwin
+  confine :operatingsystem => :darwin
+  defaultfor :operatingsystem => :darwin
 
-    # hurray for abstraction. The nameservice directoryservice provider can
-    # handle everything we need. super.
+  # hurray for abstraction. The nameservice directoryservice provider can
+  # handle everything we need. super.
 end

data/lib/puppet/provider/confine.rb

@@ -3,78 +3,78 @@
 require 'puppet/util'
 
 class Puppet::Provider::Confine
-    include Puppet::Util
+  include Puppet::Util
 
-    @tests = {}
+  @tests = {}
 
-    class << self
-        attr_accessor :name
-    end
+  class << self
+    attr_accessor :name
+  end
 
-    def self.inherited(klass)
-        name = klass.to_s.split("::").pop.downcase.to_sym
-        raise "Test %s is already defined" % name if @tests.include?(name)
+  def self.inherited(klass)
+    name = klass.to_s.split("::").pop.downcase.to_sym
+    raise "Test #{name} is already defined" if @tests.include?(name)
 
-        klass.name = name
+    klass.name = name
 
-        @tests[name] = klass
-    end
+    @tests[name] = klass
+  end
 
-    def self.test(name)
-        unless @tests[name]
-            begin
-                require "puppet/provider/confine/%s" % name
-            rescue LoadError => detail
-                unless detail.to_s =~ /No such file/i
-                    warn "Could not load confine test '%s': %s" % [name, detail]
-                end
-                # Could not find file
-            end
+  def self.test(name)
+    unless @tests[name]
+      begin
+        require "puppet/provider/confine/#{name}"
+      rescue LoadError => detail
+        unless detail.to_s =~ /No such file/i
+          warn "Could not load confine test '#{name}': #{detail}"
         end
-        return @tests[name]
-    end
-
-    attr_reader :values
-
-    # Mark that this confine is used for testing binary existence.
-    attr_accessor :for_binary
-    def for_binary?
-        for_binary
+        # Could not find file
+      end
     end
-
-    # Used for logging.
-    attr_accessor :label
-
-    def initialize(values)
-        values = [values] unless values.is_a?(Array)
-        @values = values
+    @tests[name]
+  end
+
+  attr_reader :values
+
+  # Mark that this confine is used for testing binary existence.
+  attr_accessor :for_binary
+  def for_binary?
+    for_binary
+  end
+
+  # Used for logging.
+  attr_accessor :label
+
+  def initialize(values)
+    values = [values] unless values.is_a?(Array)
+    @values = values
+  end
+
+  # Provide a hook for the message when there's a failure.
+  def message(value)
+    ""
+  end
+
+  # Collect the results of all of them.
+  def result
+    values.collect { |value| pass?(value) }
+  end
+
+  # Test whether our confine matches.
+  def valid?
+    values.each do |value|
+      unless pass?(value)
+        Puppet.debug(label + ": " + message(value))
+        return false
+      end
     end
 
-    # Provide a hook for the message when there's a failure.
-    def message(value)
-        ""
-    end
+    return true
+  ensure
+    reset
+  end
 
-    # Collect the results of all of them.
-    def result
-        values.collect { |value| pass?(value) }
-    end
-
-    # Test whether our confine matches.
-    def valid?
-        values.each do |value|
-            unless pass?(value)
-                Puppet.debug(label + ": " + message(value))
-                return false
-            end
-        end
-
-        return true
-    ensure
-        reset
-    end
-
-    # Provide a hook for subclasses.
-    def reset
-    end
+  # Provide a hook for subclasses.
+  def reset
+  end
 end

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

@@ -1,22 +1,22 @@
 require 'puppet/provider/confine'
 
 class Puppet::Provider::Confine::Exists < Puppet::Provider::Confine
-    def self.summarize(confines)
-        confines.inject([]) { |total, confine| total + confine.summary }
-    end
+  def self.summarize(confines)
+    confines.inject([]) { |total, confine| total + confine.summary }
+  end
 
-    def pass?(value)
-        if for_binary?
-            return false unless value = binary(value)
-        end
-        value and FileTest.exist?(value)
+  def pass?(value)
+    if for_binary?
+      return false unless value = binary(value)
     end
+    value and FileTest.exist?(value)
+  end
 
-    def message(value)
-        "file %s does not exist" % value
-    end
+  def message(value)
+    "file #{value} does not exist"
+  end
 
-    def summary
-        result.zip(values).inject([]) { |array, args| val, f = args; array << f unless val; array }
-    end
+  def summary
+    result.zip(values).inject([]) { |array, args| val, f = args; array << f unless val; array }
+  end
 end

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

@@ -1,19 +1,19 @@
 require 'puppet/provider/confine'
 
 class Puppet::Provider::Confine::False < Puppet::Provider::Confine
-    def self.summarize(confines)
-        confines.inject(0) { |count, confine| count + confine.summary }
-    end
+  def self.summarize(confines)
+    confines.inject(0) { |count, confine| count + confine.summary }
+  end
 
-    def pass?(value)
-        ! value
-    end
+  def pass?(value)
+    ! value
+  end
 
-    def message(value)
-        "true value when expecting false"
-    end
+  def message(value)
+    "true value when expecting false"
+  end
 
-    def summary
-        result.find_all { |v| v == false }.length
-    end
+  def summary
+    result.find_all { |v| v == false }.length
+  end
 end

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

@@ -1,17 +1,17 @@
 require 'puppet/provider/confine'
 
 class Puppet::Provider::Confine::Feature < Puppet::Provider::Confine
-    def self.summarize(confines)
-        confines.collect { |c| c.values }.flatten.uniq.find_all { |value| ! confines[0].pass?(value) }
-    end
+  def self.summarize(confines)
+    confines.collect { |c| c.values }.flatten.uniq.find_all { |value| ! confines[0].pass?(value) }
+  end
 
-    # Is the named feature available?
-    def pass?(value)
-        Puppet.features.send(value.to_s + "?")
-    end
+  # Is the named feature available?
+  def pass?(value)
+    Puppet.features.send(value.to_s + "?")
+  end
 
-    def message(value)
-        "feature %s is missing" % value
-    end
+  def message(value)
+    "feature #{value} is missing"
+  end
 end
 

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

@@ -1,20 +1,20 @@
 require 'puppet/provider/confine'
 
 class Puppet::Provider::Confine::True < Puppet::Provider::Confine
-    def self.summarize(confines)
-        confines.inject(0) { |count, confine| count + confine.summary }
-    end
+  def self.summarize(confines)
+    confines.inject(0) { |count, confine| count + confine.summary }
+  end
 
-    def pass?(value)
-        # Double negate, so we only get true or false.
-        ! ! value
-    end
+  def pass?(value)
+    # Double negate, so we only get true or false.
+    ! ! value
+  end
 
-    def message(value)
-        "false value when expecting true"
-    end
+  def message(value)
+    "false value when expecting true"
+  end
 
-    def summary
-        result.find_all { |v| v == true }.length
-    end
+  def summary
+    result.find_all { |v| v == true }.length
+  end
 end

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

@@ -5,58 +5,55 @@ require 'puppet/provider/confine'
 # is set explicitly by the ConfineCollection class -- from this class,
 # it's not obvious how the name would ever get set.
 class Puppet::Provider::Confine::Variable < Puppet::Provider::Confine
-    # Provide a hash summary of failing confines -- the key of the hash
-    # is the name of the confine, and the value is the missing yet required values.
-    # Only returns failed values, not all required values.
-    def self.summarize(confines)
-        result = Hash.new { |hash, key| hash[key] = [] }
-        confines.inject(result) { |total, confine| total[confine.name] += confine.values unless confine.valid?; total }
-    end
-
-    # This is set by ConfineCollection.
-    attr_accessor :name
-
-    # Retrieve the value from facter
-    def facter_value
-        unless defined?(@facter_value) and @facter_value
-            @facter_value = ::Facter.value(name).to_s.downcase
-        end
-        @facter_value
-    end
-
-    def initialize(values)
-        super
-        @values = @values.collect { |v| v.to_s.downcase }
-    end
-
-    def message(value)
-        "facter value '%s' for '%s' not in required list '%s'" % [test_value, self.name, values.join(",")]
-    end
-
-    # Compare the passed-in value to the retrieved value.
-    def pass?(value)
-        test_value.downcase.to_s == value.to_s.downcase
-    end
-
-    def reset
-        # Reset the cache.  We want to cache it during a given
-        # run, but not across runs.
-        @facter_value = nil
-    end
-
-    def valid?
-        @values.include?(test_value.to_s.downcase)
-    ensure
-        reset
-    end
-
-    private
-
-    def setting?
-        Puppet.settings.valid?(name)
-    end
-
-    def test_value
-        setting? ? Puppet.settings[name] : facter_value
-    end
+  # Provide a hash summary of failing confines -- the key of the hash
+  # is the name of the confine, and the value is the missing yet required values.
+  # Only returns failed values, not all required values.
+  def self.summarize(confines)
+    result = Hash.new { |hash, key| hash[key] = [] }
+    confines.inject(result) { |total, confine| total[confine.name] += confine.values unless confine.valid?; total }
+  end
+
+  # This is set by ConfineCollection.
+  attr_accessor :name
+
+  # Retrieve the value from facter
+  def facter_value
+    @facter_value ||= ::Facter.value(name).to_s.downcase
+  end
+
+  def initialize(values)
+    super
+    @values = @values.collect { |v| v.to_s.downcase }
+  end
+
+  def message(value)
+    "facter value '#{test_value}' for '#{self.name}' not in required list '#{values.join(",")}'"
+  end
+
+  # Compare the passed-in value to the retrieved value.
+  def pass?(value)
+    test_value.downcase.to_s == value.to_s.downcase
+  end
+
+  def reset
+    # Reset the cache.  We want to cache it during a given
+    # run, but not across runs.
+    @facter_value = nil
+  end
+
+  def valid?
+    @values.include?(test_value.to_s.downcase)
+  ensure
+    reset
+  end
+
+  private
+
+  def setting?
+    Puppet.settings.valid?(name)
+  end
+
+  def test_value
+    setting? ? Puppet.settings[name] : facter_value
+  end
 end

data/lib/puppet/provider/confine_collection.rb

@@ -3,48 +3,48 @@
 require 'puppet/provider/confine'
 
 class Puppet::Provider::ConfineCollection
-    def confine(hash)
-        if hash.include?(:for_binary)
-            for_binary = true
-            hash.delete(:for_binary)
-        else
-            for_binary = false
-        end
-        hash.each do |test, values|
-            if klass = Puppet::Provider::Confine.test(test)
-                @confines << klass.new(values)
-                @confines[-1].for_binary = true if for_binary
-            else
-                confine = Puppet::Provider::Confine.test(:variable).new(values)
-                confine.name = test
-                @confines << confine
-            end
-            @confines[-1].label = self.label
-        end
+  def confine(hash)
+    if hash.include?(:for_binary)
+      for_binary = true
+      hash.delete(:for_binary)
+    else
+      for_binary = false
     end
-
-    attr_reader :label
-    def initialize(label)
-        @label = label
-        @confines = []
+    hash.each do |test, values|
+      if klass = Puppet::Provider::Confine.test(test)
+        @confines << klass.new(values)
+        @confines[-1].for_binary = true if for_binary
+      else
+        confine = Puppet::Provider::Confine.test(:variable).new(values)
+        confine.name = test
+        @confines << confine
+      end
+      @confines[-1].label = self.label
     end
+  end
 
-    # Return a hash of the whole confine set, used for the Provider
-    # reference.
-    def summary
-        confines = Hash.new { |hash, key| hash[key] = [] }
-        @confines.each { |confine| confines[confine.class] << confine }
-        result = {}
-        confines.each do |klass, list|
-            value = klass.summarize(list)
-            next if (value.respond_to?(:length) and value.length == 0) or (value == 0)
-            result[klass.name] = value
+  attr_reader :label
+  def initialize(label)
+    @label = label
+    @confines = []
+  end
 
-        end
-        result
-    end
+  # Return a hash of the whole confine set, used for the Provider
+  # reference.
+  def summary
+    confines = Hash.new { |hash, key| hash[key] = [] }
+    @confines.each { |confine| confines[confine.class] << confine }
+    result = {}
+    confines.each do |klass, list|
+      value = klass.summarize(list)
+      next if (value.respond_to?(:length) and value.length == 0) or (value == 0)
+      result[klass.name] = value
 
-    def valid?
-        ! @confines.detect { |c| ! c.valid? }
     end
+    result
+  end
+
+  def valid?
+    ! @confines.detect { |c| ! c.valid? }
+  end
 end