puppet 0.24.9 → 0.25.0

data/lib/puppet/external/event-loop/better-definers.rb

@@ -18,350 +18,350 @@
 # Boston, MA 02110-1301, USA.
 
 class Symbol
-  def predicate?
-    to_s.include? "?" end
-  def imperative?
-    to_s.include? "!" end
-  def writer?
-    to_s.include? "=" end
-
-  def punctuated?
-    predicate? or imperative? or writer? end
-  def without_punctuation
-    to_s.delete("?!=").to_sym end
-
-  def predicate
-    without_punctuation.to_s + "?" end
-  def imperative
-    without_punctuation.to_s + "!" end
-  def writer
-    without_punctuation.to_s + "=" end
+    def predicate?
+        to_s.include? "?" end
+    def imperative?
+        to_s.include? "!" end
+    def writer?
+        to_s.include? "=" end
+
+    def punctuated?
+        predicate? or imperative? or writer? end
+    def without_punctuation
+        to_s.delete("?!=").to_sym end
+
+    def predicate
+        without_punctuation.to_s + "?" end
+    def imperative
+        without_punctuation.to_s + "!" end
+    def writer
+        without_punctuation.to_s + "=" end
 end
 
 class Hash
-  def collect! (&block)
-    replace Hash[*collect(&block).flatten]
-  end
+    def collect! (&block)
+        replace Hash[*collect(&block).flatten]
+    end
 
-  def flatten
-    to_a.flatten
-  end
+    def flatten
+        to_a.flatten
+    end
 end
 
 module Kernel
-  def returning (value)
-    yield value ; value
-  end
+    def returning (value)
+        yield value ; value
+    end
 end
 
 class Module
-  def define_hard_aliases (name_pairs)
-    for new_aliases, existing_name in name_pairs do
-      new_aliases.kind_of? Array or new_aliases = [new_aliases]
-      for new_alias in new_aliases do
-        alias_method(new_alias, existing_name)
-      end
+    def define_hard_aliases (name_pairs)
+        for new_aliases, existing_name in name_pairs do
+            new_aliases.kind_of? Array or new_aliases = [new_aliases]
+            for new_alias in new_aliases do
+                alias_method(new_alias, existing_name)
+            end
+        end
     end
-  end
-
-  def define_soft_aliases (name_pairs)
-    for new_aliases, existing_name in name_pairs do
-      new_aliases.kind_of? Array or new_aliases = [new_aliases]
-      for new_alias in new_aliases do
-        class_eval %{def #{new_alias}(*args, &block)
-                       #{existing_name}(*args, &block) end}
-      end
+
+    def define_soft_aliases (name_pairs)
+        for new_aliases, existing_name in name_pairs do
+            new_aliases.kind_of? Array or new_aliases = [new_aliases]
+            for new_alias in new_aliases do
+                class_eval %{def #{new_alias}(*args, &block)
+                            #{existing_name}(*args, &block) end}
+            end
+        end
     end
-  end
-
-  define_soft_aliases \
-    :define_hard_alias => :define_hard_aliases,
-    :define_soft_alias => :define_soft_aliases
-
-  # This method lets you define predicates like :foo?,
-  # which will be defined to return the value of @foo.
-  def define_readers (*names)
-    for name in names.map { |x| x.to_sym } do
-      if name.punctuated?
-        # There's no way to define an efficient reader whose
-        # name is different from the instance variable.
-        class_eval %{def #{name} ; @#{name.without_punctuation} end}
-      else
-        # Use `attr_reader' to define an efficient method.
-        attr_reader(name)
-      end
+
+    define_soft_aliases \
+        :define_hard_alias => :define_hard_aliases,
+        :define_soft_alias => :define_soft_aliases
+
+    # This method lets you define predicates like :foo?,
+    # which will be defined to return the value of @foo.
+    def define_readers (*names)
+        for name in names.map { |x| x.to_sym } do
+            if name.punctuated?
+                # There's no way to define an efficient reader whose
+                # name is different from the instance variable.
+                class_eval %{def #{name} ; @#{name.without_punctuation} end}
+            else
+                # Use `attr_reader' to define an efficient method.
+                attr_reader(name)
+            end
+        end
+    end
+
+    def writer_defined? (name)
+        method_defined? name.to_sym.writer
     end
-  end
-
-  def writer_defined? (name)
-    method_defined? name.to_sym.writer
-  end
-
-  # If you pass a predicate symbol :foo? to this method, it'll first
-  # define a regular writer method :foo, without a question mark.
-  # Then it'll define an imperative writer method :foo! as a shorthand
-  # for setting the property to true.
-  def define_writers (*names, &body)
-    for name in names.map { |x| x.to_sym } do
-      if block_given?
-        define_method(name.writer, &body)
-      else
-        attr_writer(name.without_punctuation)
-      end
-      if name.predicate?
-        class_eval %{def #{name.imperative}
-                       self.#{name.writer} true end}
-      end
+
+    # If you pass a predicate symbol :foo? to this method, it'll first
+    # define a regular writer method :foo, without a question mark.
+    # Then it'll define an imperative writer method :foo! as a shorthand
+    # for setting the property to true.
+    def define_writers (*names, &body)
+        for name in names.map { |x| x.to_sym } do
+            if block_given?
+                define_method(name.writer, &body)
+            else
+                attr_writer(name.without_punctuation)
+            end
+            if name.predicate?
+                class_eval %{def #{name.imperative}
+                           self.#{name.writer} true end}
+            end
+        end
     end
-  end
 
-  define_soft_aliases \
-    :define_reader => :define_readers,
-    :define_writer => :define_writers
+    define_soft_aliases \
+        :define_reader => :define_readers,
+        :define_writer => :define_writers
 
-  # We don't need a singular alias for `define_accessors',
-  # because it always defines at least two methods.
+    # We don't need a singular alias for `define_accessors',
+    # because it always defines at least two methods.
 
-  def define_accessors (*names)
-    define_readers(*names)
-    define_writers(*names)
-  end
+    def define_accessors (*names)
+        define_readers(*names)
+        define_writers(*names)
+    end
 
-  def define_opposite_readers (name_pairs)
-    name_pairs.collect! { |k, v| [k.to_sym, v.to_sym] }
-    for opposite_name, name in name_pairs do
-      define_reader(name) unless method_defined? name
-      class_eval %{def #{opposite_name} ; not #{name} end}
+    def define_opposite_readers (name_pairs)
+        name_pairs.collect! { |k, v| [k.to_sym, v.to_sym] }
+        for opposite_name, name in name_pairs do
+            define_reader(name) unless method_defined? name
+            class_eval %{def #{opposite_name} ; not #{name} end}
+        end
     end
-  end
-
-  def define_opposite_writers (name_pairs)
-    name_pairs.collect! { |k, v| [k.to_sym, v.to_sym] }
-    for opposite_name, name in name_pairs do
-      define_writer(name) unless writer_defined? name
-      class_eval %{def #{opposite_name.writer} x
-                     self.#{name.writer} !x end} 
-      class_eval %{def #{opposite_name.imperative}
-                     self.#{name.writer} false end}
+
+    def define_opposite_writers (name_pairs)
+        name_pairs.collect! { |k, v| [k.to_sym, v.to_sym] }
+        for opposite_name, name in name_pairs do
+            define_writer(name) unless writer_defined? name
+            class_eval %{def #{opposite_name.writer} x
+                         self.#{name.writer} !x end}
+            class_eval %{def #{opposite_name.imperative}
+                         self.#{name.writer} false end}
+        end
     end
-  end
 
-  define_soft_aliases \
-    :define_opposite_reader => :define_opposite_readers,
-    :define_opposite_writer => :define_opposite_writers
+    define_soft_aliases \
+        :define_opposite_reader => :define_opposite_readers,
+        :define_opposite_writer => :define_opposite_writers
 
-  def define_opposite_accessors (name_pairs)
-    define_opposite_readers name_pairs
-    define_opposite_writers name_pairs
-  end
+    def define_opposite_accessors (name_pairs)
+        define_opposite_readers name_pairs
+        define_opposite_writers name_pairs
+    end
 
-  def define_reader_with_opposite (name_pair, &body)
-    name, opposite_name = name_pair.flatten.collect { |x| x.to_sym }
-    define_method(name, &body)
-    define_opposite_reader(opposite_name => name)
-  end
+    def define_reader_with_opposite (name_pair, &body)
+        name, opposite_name = name_pair.flatten.collect { |x| x.to_sym }
+        define_method(name, &body)
+        define_opposite_reader(opposite_name => name)
+    end
 
-  def define_writer_with_opposite (name_pair, &body)
-    name, opposite_name = name_pair.flatten.collect { |x| x.to_sym }
-    define_writer(name, &body)
-    define_opposite_writer(opposite_name => name)
-  end
+    def define_writer_with_opposite (name_pair, &body)
+        name, opposite_name = name_pair.flatten.collect { |x| x.to_sym }
+        define_writer(name, &body)
+        define_opposite_writer(opposite_name => name)
+    end
 
   public :define_method
 
-  def define_methods (*names, &body)
-    names.each { |name| define_method(name, &body) }
-  end
-  
-  def define_private_methods (*names, &body)
-    define_methods(*names, &body)
-    names.each { |name| private name }
-  end
-
-  def define_protected_methods (*names, &body)
-    define_methods(*names, &body)
-    names.each { |name| protected name }
-  end
-
-  def define_private_method (name, &body)
-    define_method(name, &body)
-    private name
-  end
-
-  def define_protected_method (name, &body)
-    define_method(name, &body)
-    protected name
-  end
+    def define_methods (*names, &body)
+        names.each { |name| define_method(name, &body) }
+    end
+
+    def define_private_methods (*names, &body)
+        define_methods(*names, &body)
+        names.each { |name| private name }
+    end
+
+    def define_protected_methods (*names, &body)
+        define_methods(*names, &body)
+        names.each { |name| protected name }
+    end
+
+    def define_private_method (name, &body)
+        define_method(name, &body)
+        private name
+    end
+
+    def define_protected_method (name, &body)
+        define_method(name, &body)
+        protected name
+    end
 end
 
 class ImmutableAttributeError < StandardError
-  def initialize (attribute=nil, message=nil)
-    super message
-    @attribute = attribute
-  end
-
-  define_accessors :attribute
-
-  def to_s
-    if @attribute and @message
-      "cannot change the value of `#@attribute': #@message"
-    elsif @attribute
-      "cannot change the value of `#@attribute'"
-    elsif @message
-      "cannot change the value of attribute: #@message"
-    else
-      "cannot change the value of attribute"
+    def initialize (attribute=nil, message=nil)
+        super message
+        @attribute = attribute
+    end
+
+    define_accessors :attribute
+
+    def to_s
+        if @attribute and @message
+            "cannot change the value of `#@attribute': #@message"
+        elsif @attribute
+            "cannot change the value of `#@attribute'"
+        elsif @message
+            "cannot change the value of attribute: #@message"
+        else
+            "cannot change the value of attribute"
+        end
     end
-  end
 end
 
 class Module
-  # Guard each of the specified attributes by replacing the writer
-  # method with a proxy that asks the supplied block before proceeding
-  # with the change.
-  #
-  # If it's okay to change the attribute, the block should return
-  # either nil or the symbol :mutable.  If it isn't okay, the block
-  # should return a string saying why the attribute can't be changed.
-  # If you don't want to provide a reason, you can have the block
-  # return just the symbol :immutable.
-  def guard_writers(*names, &predicate)
-    for name in names.map { |x| x.to_sym } do
-      define_hard_alias("__unguarded_#{name.writer}" => name.writer)
-      define_method(name.writer) do |new_value|
-        case result = predicate.call
-        when :mutable, nil
-          __send__("__unguarded_#{name.writer}", new_value)
-        when :immutable
-          raise ImmutableAttributeError.new(name)
-        else
-          raise ImmutableAttributeError.new(name, result)
+    # Guard each of the specified attributes by replacing the writer
+    # method with a proxy that asks the supplied block before proceeding
+    # with the change.
+    #
+    # If it's okay to change the attribute, the block should return
+    # either nil or the symbol :mutable.  If it isn't okay, the block
+    # should return a string saying why the attribute can't be changed.
+    # If you don't want to provide a reason, you can have the block
+    # return just the symbol :immutable.
+    def guard_writers(*names, &predicate)
+        for name in names.map { |x| x.to_sym } do
+            define_hard_alias("__unguarded_#{name.writer}" => name.writer)
+            define_method(name.writer) do |new_value|
+                case result = predicate.call
+                when :mutable, nil
+                    __send__("__unguarded_#{name.writer}", new_value)
+                when :immutable
+                    raise ImmutableAttributeError.new(name)
+                else
+                    raise ImmutableAttributeError.new(name, result)
+                end
+            end
         end
-      end
     end
-  end
 
-  def define_guarded_writers (*names, &block)
-    define_writers(*names)
-    guard_writers(*names, &block)
-  end
+    def define_guarded_writers (*names, &block)
+        define_writers(*names)
+        guard_writers(*names, &block)
+    end
 
-  define_soft_alias :guard_writer => :guard_writers
-  define_soft_alias :define_guarded_writer => :define_guarded_writers
+    define_soft_alias :guard_writer => :guard_writers
+    define_soft_alias :define_guarded_writer => :define_guarded_writers
 end
 
 if __FILE__ == $0
-  require "test/unit"
-
-  class DefineAccessorsTest < Test::Unit::TestCase
-    def setup
-      @X = Class.new
-      @Y = Class.new @X
-      @x = @X.new
-      @y = @Y.new
-    end
+    require "test/unit"
+
+    class DefineAccessorsTest < Test::Unit::TestCase
+        def setup
+            @X = Class.new
+            @Y = Class.new @X
+            @x = @X.new
+            @y = @Y.new
+        end
 
-    def test_define_hard_aliases
-      @X.define_method(:foo) { 123 }
-      @X.define_method(:baz) { 321 }
-      @X.define_hard_aliases :bar => :foo, :quux => :baz
-      assert_equal @x.foo, 123
-      assert_equal @x.bar, 123
-      assert_equal @y.foo, 123
-      assert_equal @y.bar, 123
-      assert_equal @x.baz, 321
-      assert_equal @x.quux, 321
-      assert_equal @y.baz, 321
-      assert_equal @y.quux, 321
-      @Y.define_method(:foo) { 456 }
-      assert_equal @y.foo, 456
-      assert_equal @y.bar, 123
-      @Y.define_method(:quux) { 654 }
-      assert_equal @y.baz, 321
-      assert_equal @y.quux, 654
-    end
-    
-    def test_define_soft_aliases
-      @X.define_method(:foo) { 123 }
-      @X.define_method(:baz) { 321 }
-      @X.define_soft_aliases :bar => :foo, :quux => :baz
-      assert_equal @x.foo, 123
-      assert_equal @x.bar, 123
-      assert_equal @y.foo, 123
-      assert_equal @y.bar, 123
-      assert_equal @x.baz, 321
-      assert_equal @x.quux, 321
-      assert_equal @y.baz, 321
-      assert_equal @y.quux, 321
-      @Y.define_method(:foo) { 456 }
-      assert_equal @y.foo, @y.bar, 456
-      @Y.define_method(:quux) { 654 }
-      assert_equal @y.baz, 321
-      assert_equal @y.quux, 654
-    end
+        def test_define_hard_aliases
+            @X.define_method(:foo) { 123 }
+            @X.define_method(:baz) { 321 }
+            @X.define_hard_aliases :bar => :foo, :quux => :baz
+            assert_equal @x.foo, 123
+            assert_equal @x.bar, 123
+            assert_equal @y.foo, 123
+            assert_equal @y.bar, 123
+            assert_equal @x.baz, 321
+            assert_equal @x.quux, 321
+            assert_equal @y.baz, 321
+            assert_equal @y.quux, 321
+            @Y.define_method(:foo) { 456 }
+            assert_equal @y.foo, 456
+            assert_equal @y.bar, 123
+            @Y.define_method(:quux) { 654 }
+            assert_equal @y.baz, 321
+            assert_equal @y.quux, 654
+        end
 
-    def test_define_readers
-      @X.define_readers :foo, :bar
-      assert !@x.respond_to?(:foo=)
-      assert !@x.respond_to?(:bar=)
-      @x.instance_eval { @foo = 123 ; @bar = 456 }
-      assert_equal @x.foo, 123
-      assert_equal @x.bar, 456
-      @X.define_readers :baz?, :quux?
-      assert !@x.respond_to?(:baz=)
-      assert !@x.respond_to?(:quux=)
-      @x.instance_eval { @baz = false ; @quux = true }
-      assert !@x.baz?
-      assert @x.quux?
-    end
+        def test_define_soft_aliases
+            @X.define_method(:foo) { 123 }
+            @X.define_method(:baz) { 321 }
+            @X.define_soft_aliases :bar => :foo, :quux => :baz
+            assert_equal @x.foo, 123
+            assert_equal @x.bar, 123
+            assert_equal @y.foo, 123
+            assert_equal @y.bar, 123
+            assert_equal @x.baz, 321
+            assert_equal @x.quux, 321
+            assert_equal @y.baz, 321
+            assert_equal @y.quux, 321
+            @Y.define_method(:foo) { 456 }
+            assert_equal @y.foo, @y.bar, 456
+            @Y.define_method(:quux) { 654 }
+            assert_equal @y.baz, 321
+            assert_equal @y.quux, 654
+        end
 
-    def test_define_writers
-      assert !@X.writer_defined?(:foo)
-      assert !@X.writer_defined?(:bar)
-      @X.define_writers :foo, :bar
-      assert @X.writer_defined?(:foo)
-      assert @X.writer_defined?(:bar)
-      assert @X.writer_defined?(:foo=)
-      assert @X.writer_defined?(:bar=)
-      assert @X.writer_defined?(:foo?)
-      assert @X.writer_defined?(:bar?)
-      assert !@x.respond_to?(:foo)
-      assert !@x.respond_to?(:bar)
-      @x.foo = 123
-      @x.bar = 456
-      assert_equal @x.instance_eval { @foo }, 123
-      assert_equal @x.instance_eval { @bar }, 456
-      @X.define_writers :baz?, :quux?
-      assert !@x.respond_to?(:baz?)
-      assert !@x.respond_to?(:quux?)
-      @x.baz = true
-      @x.quux = false
-      assert_equal @x.instance_eval { @baz }, true
-      assert_equal @x.instance_eval { @quux }, false
-    end
+        def test_define_readers
+            @X.define_readers :foo, :bar
+            assert !@x.respond_to?(:foo=)
+            assert !@x.respond_to?(:bar=)
+            @x.instance_eval { @foo = 123 ; @bar = 456 }
+            assert_equal @x.foo, 123
+            assert_equal @x.bar, 456
+            @X.define_readers :baz?, :quux?
+            assert !@x.respond_to?(:baz=)
+            assert !@x.respond_to?(:quux=)
+            @x.instance_eval { @baz = false ; @quux = true }
+            assert !@x.baz?
+            assert @x.quux?
+        end
 
-    def test_define_accessors
-      @X.define_accessors :foo, :bar
-      @x.foo = 123 ; @x.bar = 456
-      assert_equal @x.foo, 123
-      assert_equal @x.bar, 456
-    end
+        def test_define_writers
+            assert !@X.writer_defined?(:foo)
+            assert !@X.writer_defined?(:bar)
+            @X.define_writers :foo, :bar
+            assert @X.writer_defined?(:foo)
+            assert @X.writer_defined?(:bar)
+            assert @X.writer_defined?(:foo=)
+            assert @X.writer_defined?(:bar=)
+            assert @X.writer_defined?(:foo?)
+            assert @X.writer_defined?(:bar?)
+            assert !@x.respond_to?(:foo)
+            assert !@x.respond_to?(:bar)
+            @x.foo = 123
+            @x.bar = 456
+            assert_equal @x.instance_eval { @foo }, 123
+            assert_equal @x.instance_eval { @bar }, 456
+            @X.define_writers :baz?, :quux?
+            assert !@x.respond_to?(:baz?)
+            assert !@x.respond_to?(:quux?)
+            @x.baz = true
+            @x.quux = false
+            assert_equal @x.instance_eval { @baz }, true
+            assert_equal @x.instance_eval { @quux }, false
+        end
 
-    def test_define_opposite_readers
-      @X.define_opposite_readers :foo? => :bar?, :baz? => :quux?
-      assert !@x.respond_to?(:foo=)
-      assert !@x.respond_to?(:bar=)
-      assert !@x.respond_to?(:baz=)
-      assert !@x.respond_to?(:quux=)
-      @x.instance_eval { @bar = true ; @quux = false }
-      assert !@x.foo?
-      assert @x.bar?
-      assert @x.baz?
-      assert !@x.quux?
-    end
+        def test_define_accessors
+            @X.define_accessors :foo, :bar
+            @x.foo = 123 ; @x.bar = 456
+            assert_equal @x.foo, 123
+            assert_equal @x.bar, 456
+        end
 
-    def test_define_opposite_writers
-      @X.define_opposite_writers :foo? => :bar?, :baz => :quux
+        def test_define_opposite_readers
+            @X.define_opposite_readers :foo? => :bar?, :baz? => :quux?
+            assert !@x.respond_to?(:foo=)
+            assert !@x.respond_to?(:bar=)
+            assert !@x.respond_to?(:baz=)
+            assert !@x.respond_to?(:quux=)
+            @x.instance_eval { @bar = true ; @quux = false }
+            assert !@x.foo?
+            assert @x.bar?
+            assert @x.baz?
+            assert !@x.quux?
+        end
+
+        def test_define_opposite_writers
+            @X.define_opposite_writers :foo? => :bar?, :baz => :quux
+        end
     end
-  end
 end