puppet-retrospec 0.7.0 → 0.7.2

data/vendor/gems/puppet-3.7.3/lib/puppet/util/classgen.rb

@@ -0,0 +1,236 @@
+require 'puppet/util/methodhelper'
+
+module Puppet
+  class ConstantAlreadyDefined < Error; end
+  class SubclassAlreadyDefined < Error; end
+end
+
+# This is a utility module for generating classes.
+# @api public
+#
+module Puppet::Util::ClassGen
+  include Puppet::Util::MethodHelper
+  include Puppet::Util
+
+  # Create a new class.
+  # @param name [String] the name of the generated class
+  # @param options [Hash] a hash of options
+  # @option options [Array<Class>] :array if specified, the generated class is appended to this array
+  # @option options [Hash<{String => Object}>] :attributes a hash that is applied to the generated class
+  #   by calling setter methods corresponding to this hash's keys/value pairs. This is done before the given
+  #   block is evaluated.
+  # @option options [Proc] :block a block to evaluate in the context of the class (this block can be provided
+  #   this way, or as a normal yield block).
+  # @option options [String] :constant (name with first letter capitalized) what to set the constant that references
+  #   the generated class to.
+  # @option options [Hash] :hash a hash of existing classes that this class is appended to (name => class).
+  #   This hash must be specified if the `:overwrite` option is set to `true`.
+  # @option options [Boolean] :overwrite whether an overwrite of an existing class should be allowed (requires also
+  #   defining the `:hash` with existing classes as the test is based on the content of this hash).
+  # @option options [Class] :parent (self) the parent class of the generated class.
+  # @option options [String] ('') :prefix the constant prefix to prepend to the constant name referencing the
+  #   generated class.
+  # @return [Class] the generated class
+  #
+  def genclass(name, options = {}, &block)
+    genthing(name, Class, options, block)
+  end
+
+  # Creates a new module.
+  # @param name [String] the name of the generated module
+  # @param options [Hash] hash with options
+  # @option options [Array<Class>] :array if specified, the generated class is appended to this array
+  # @option options [Hash<{String => Object}>] :attributes a hash that is applied to the generated class
+  #   by calling setter methods corresponding to this hash's keys/value pairs. This is done before the given
+  #   block is evaluated.
+  # @option options [Proc] :block a block to evaluate in the context of the class (this block can be provided
+  #   this way, or as a normal yield block).
+  # @option options [String] :constant (name with first letter capitalized) what to set the constant that references
+  #   the generated class to.
+  # @option options [Hash] :hash a hash of existing classes that this class is appended to (name => class).
+  #   This hash must be specified if the `:overwrite` option is set to `true`.
+  # @option options [Boolean] :overwrite whether an overwrite of an existing class should be allowed (requires also
+  #   defining the `:hash` with existing classes as the test is based on the content of this hash).
+  #   the capitalized name is appended and the result is set as the constant.
+  # @option options [String] ('') :prefix the constant prefix to prepend to the constant name referencing the
+  #   generated class.
+  # @return [Module] the generated Module
+  def genmodule(name, options = {}, &block)
+    genthing(name, Module, options, block)
+  end
+
+  # Removes an existing class.
+  # @param name [String] the name of the class to remove
+  # @param options [Hash] options
+  # @option options [Hash] :hash a hash of existing classes from which the class to be removed is also removed
+  # @return [Boolean] whether the class was removed or not
+  #
+  def rmclass(name, options)
+    options = symbolize_options(options)
+    const = genconst_string(name, options)
+    retval = false
+    if is_constant_defined?(const)
+      remove_const(const)
+      retval = true
+    end
+
+    if hash = options[:hash] and hash.include? name
+      hash.delete(name)
+      retval = true
+    end
+
+    # Let them know whether we did actually delete a subclass.
+    retval
+  end
+
+  private
+
+  # Generates the constant to create or remove.
+  # @api private
+  def genconst_string(name, options)
+    unless const = options[:constant]
+      prefix = options[:prefix] || ""
+      const = prefix + name2const(name)
+    end
+
+    const
+  end
+
+  # This does the actual work of creating our class or module.  It's just a
+  # slightly abstract version of genclass.
+  # @api private
+  def genthing(name, type, options, block)
+    options = symbolize_options(options)
+
+    name = name.to_s.downcase.intern
+
+    if type == Module
+      #evalmethod = :module_eval
+      evalmethod = :class_eval
+      # Create the class, with the correct name.
+      klass = Module.new do
+        class << self
+          attr_reader :name
+        end
+        @name = name
+      end
+    else
+      options[:parent] ||= self
+      evalmethod = :class_eval
+      # Create the class, with the correct name.
+      klass = Class.new(options[:parent]) do
+        @name = name
+      end
+    end
+
+    # Create the constant as appropriation.
+    handleclassconst(klass, name, options)
+
+    # Initialize any necessary variables.
+    initclass(klass, options)
+
+    block ||= options[:block]
+
+    # Evaluate the passed block if there is one.  This should usually
+    # define all of the work.
+    klass.send(evalmethod, &block) if block
+
+    klass.postinit if klass.respond_to? :postinit
+
+    # Store the class in hashes or arrays or whatever.
+    storeclass(klass, name, options)
+
+    klass
+  end
+
+  # const_defined? in Ruby 1.9 behaves differently in terms
+  # of which class hierarchy it polls for nested namespaces
+  #
+  # See http://redmine.ruby-lang.org/issues/show/1915
+  # @api private
+  #
+  def is_constant_defined?(const)
+    if ::RUBY_VERSION =~ /^1\.8/
+      const_defined?(const)
+    else
+      const_defined?(const, false)
+    end
+  end
+
+  # Handle the setting and/or removing of the associated constant.
+  # @api private
+  #
+  def handleclassconst(klass, name, options)
+    const = genconst_string(name, options)
+
+    if is_constant_defined?(const)
+      if options[:overwrite]
+        Puppet.info "Redefining #{name} in #{self}"
+        remove_const(const)
+      else
+        raise Puppet::ConstantAlreadyDefined,
+          "Class #{const} is already defined in #{self}"
+      end
+    end
+    const_set(const, klass)
+
+    const
+  end
+
+  # Perform the initializations on the class.
+  # @api private
+  #
+  def initclass(klass, options)
+    klass.initvars if klass.respond_to? :initvars
+
+    if attrs = options[:attributes]
+      attrs.each do |param, value|
+        method = param.to_s + "="
+        klass.send(method, value) if klass.respond_to? method
+      end
+    end
+
+    [:include, :extend].each do |method|
+      if set = options[method]
+        set = [set] unless set.is_a?(Array)
+        set.each do |mod|
+          klass.send(method, mod)
+        end
+      end
+    end
+
+    klass.preinit if klass.respond_to? :preinit
+  end
+
+  # Convert our name to a constant.
+  # @api private
+  def name2const(name)
+    name.to_s.capitalize
+  end
+
+  # Store the class in the appropriate places.
+  # @api private
+  def storeclass(klass, klassname, options)
+    if hash = options[:hash]
+      if hash.include? klassname and ! options[:overwrite]
+        raise Puppet::SubclassAlreadyDefined,
+          "Already a generated class named #{klassname}"
+      end
+
+      hash[klassname] = klass
+    end
+
+    # If we were told to stick it in a hash, then do so
+    if array = options[:array]
+      if (klass.respond_to? :name and
+              array.find { |c| c.name == klassname } and
+              ! options[:overwrite])
+        raise Puppet::SubclassAlreadyDefined,
+          "Already a generated class named #{klassname}"
+      end
+
+      array << klass
+    end
+  end
+end
+

data/vendor/gems/puppet-3.7.3/lib/puppet/util/colors.rb

@@ -0,0 +1,217 @@
+require 'puppet/util/platform'
+
+module Puppet::Util::Colors
+  BLACK       = {:console => "\e[0;30m", :html => "color: #FFA0A0"     }
+  RED         = {:console => "\e[0;31m", :html => "color: #FFA0A0"     }
+  GREEN       = {:console => "\e[0;32m", :html => "color: #00CD00"     }
+  YELLOW      = {:console => "\e[0;33m", :html => "color: #FFFF60"     }
+  BLUE        = {:console => "\e[0;34m", :html => "color: #80A0FF"     }
+  MAGENTA     = {:console => "\e[0;35m", :html => "color: #FFA500"     }
+  CYAN        = {:console => "\e[0;36m", :html => "color: #40FFFF"     }
+  WHITE       = {:console => "\e[0;37m", :html => "color: #FFFFFF"     }
+  HBLACK      = {:console => "\e[1;30m", :html => "color: #FFA0A0"     }
+  HRED        = {:console => "\e[1;31m", :html => "color: #FFA0A0"     }
+  HGREEN      = {:console => "\e[1;32m", :html => "color: #00CD00"     }
+  HYELLOW     = {:console => "\e[1;33m", :html => "color: #FFFF60"     }
+  HBLUE       = {:console => "\e[1;34m", :html => "color: #80A0FF"     }
+  HMAGENTA    = {:console => "\e[1;35m", :html => "color: #FFA500"     }
+  HCYAN       = {:console => "\e[1;36m", :html => "color: #40FFFF"     }
+  HWHITE      = {:console => "\e[1;37m", :html => "color: #FFFFFF"     }
+  BG_RED      = {:console => "\e[0;41m", :html => "background: #FFA0A0"}
+  BG_GREEN    = {:console => "\e[0;42m", :html => "background: #00CD00"}
+  BG_YELLOW   = {:console => "\e[0;43m", :html => "background: #FFFF60"}
+  BG_BLUE     = {:console => "\e[0;44m", :html => "background: #80A0FF"}
+  BG_MAGENTA  = {:console => "\e[0;45m", :html => "background: #FFA500"}
+  BG_CYAN     = {:console => "\e[0;46m", :html => "background: #40FFFF"}
+  BG_WHITE    = {:console => "\e[0;47m", :html => "background: #FFFFFF"}
+  BG_HRED     = {:console => "\e[1;41m", :html => "background: #FFA0A0"}
+  BG_HGREEN   = {:console => "\e[1;42m", :html => "background: #00CD00"}
+  BG_HYELLOW  = {:console => "\e[1;43m", :html => "background: #FFFF60"}
+  BG_HBLUE    = {:console => "\e[1;44m", :html => "background: #80A0FF"}
+  BG_HMAGENTA = {:console => "\e[1;45m", :html => "background: #FFA500"}
+  BG_HCYAN    = {:console => "\e[1;46m", :html => "background: #40FFFF"}
+  BG_HWHITE   = {:console => "\e[1;47m", :html => "background: #FFFFFF"}
+  RESET       = {:console => "\e[0m",    :html => ""                   }
+
+  Colormap = {
+    :debug => WHITE,
+    :info => GREEN,
+    :notice => CYAN,
+    :warning => YELLOW,
+    :err => HMAGENTA,
+    :alert => RED,
+    :emerg => HRED,
+    :crit => HRED,
+
+    :black       => BLACK,
+    :red         => RED,
+    :green       => GREEN,
+    :yellow      => YELLOW,
+    :blue        => BLUE,
+    :magenta     => MAGENTA,
+    :cyan        => CYAN,
+    :white       => WHITE,
+    :hblack      => HBLACK,
+    :hred        => HRED,
+    :hgreen      => HGREEN,
+    :hyellow     => HYELLOW,
+    :hblue       => HBLUE,
+    :hmagenta    => HMAGENTA,
+    :hcyan       => HCYAN,
+    :hwhite      => HWHITE,
+    :bg_red      => BG_RED,
+    :bg_green    => BG_GREEN,
+    :bg_yellow   => BG_YELLOW,
+    :bg_blue     => BG_BLUE,
+    :bg_magenta  => BG_MAGENTA,
+    :bg_cyan     => BG_CYAN,
+    :bg_white    => BG_WHITE,
+    :bg_hred     => BG_HRED,
+    :bg_hgreen   => BG_HGREEN,
+    :bg_hyellow  => BG_HYELLOW,
+    :bg_hblue    => BG_HBLUE,
+    :bg_hmagenta => BG_HMAGENTA,
+    :bg_hcyan    => BG_HCYAN,
+    :bg_hwhite   => BG_HWHITE,
+    :reset       => { :console => "\e[m", :html => "" }
+  }
+
+  # We define console_has_color? at load time since it's checking the
+  # underlying platform which will not change, and we don't want to perform
+  # the check every time we use logging
+  if Puppet::Util::Platform.windows? && RUBY_VERSION =~ /^1\./
+    # We're on windows and using ruby less than v2
+    # so we need win32console for color to work
+    begin
+      require 'ffi'
+      require 'win32console'
+
+      # The win32console gem uses ANSI functions for writing to the console
+      # which doesn't work for unicode strings, e.g. module tool. Ruby 1.9
+      # does the same thing, but doesn't account for ANSI escape sequences
+      class WideConsole < Win32::Console
+        extend FFI::Library
+
+        # http://msdn.microsoft.com/en-us/library/windows/desktop/ms687401(v=vs.85).aspx
+        # BOOL WINAPI WriteConsole(
+        #   _In_        HANDLE hConsoleOutput,
+        #   _In_        const VOID *lpBuffer,
+        #   _In_        DWORD nNumberOfCharsToWrite,
+        #   _Out_       LPDWORD lpNumberOfCharsWritten,
+        #   _Reserved_  LPVOID lpReserved
+        # );
+        ffi_lib :kernel32
+        attach_function_private :WriteConsoleW,
+          [:handle, :lpcwstr, :dword, :lpdword, :lpvoid], :win32_bool
+
+        # typedef struct _COORD {
+        #   SHORT X;
+        #   SHORT Y;
+        # } COORD, *PCOORD;
+        class COORD < FFI::Struct
+          layout :X, :short,
+                 :Y, :short
+        end
+
+        # http://msdn.microsoft.com/en-us/library/windows/desktop/ms687410(v=vs.85).aspx
+        # BOOL WINAPI WriteConsoleOutputCharacter(
+        #   _In_   HANDLE hConsoleOutput,
+        #   _In_   LPCTSTR lpCharacter,
+        #   _In_   DWORD nLength,
+        #   _In_   COORD dwWriteCoord,
+        #   _Out_  LPDWORD lpNumberOfCharsWritten
+        # );
+        ffi_lib :kernel32
+        attach_function_private :WriteConsoleOutputCharacterW,
+          [:handle, :lpcwstr, :dword, COORD, :lpdword], :win32_bool
+
+        def initialize(t = nil)
+          super(t)
+        end
+
+        def WriteChar(str, col, row)
+          writeCoord = COORD.new()
+          writeCoord[:X] = row
+          writeCoord[:Y] = col
+
+          chars_written = 0
+          FFI::MemoryPointer.from_string_to_wide_string(str) do |msg_ptr|
+            FFI::MemoryPointer.new(:dword, 1) do |numberOfCharsWritten_ptr|
+              WriteConsoleOutputCharacterW(@handle, msg_ptr,
+                str.length, writeCoord, numberOfCharsWritten_ptr)
+              chars_written = numberOfCharsWritten_ptr.read_dword
+            end
+          end
+
+          chars_written
+        end
+
+        def Write(str)
+          result = false
+          FFI::MemoryPointer.from_string_to_wide_string(str) do |msg_ptr|
+            FFI::MemoryPointer.new(:dword, 1) do |numberOfCharsWritten_ptr|
+              result = WriteConsoleW(@handle, msg_ptr,
+                str.length, FFI::MemoryPointer.new(:dword, 1),
+                FFI::MemoryPointer::NULL) != FFI::WIN32_FALSE
+            end
+          end
+
+          result
+        end
+      end
+
+      # Override the win32console's IO class so we can supply
+      # our own Console class
+      class WideIO < Win32::Console::ANSI::IO
+        def initialize(fd_std = :stdout)
+          super(fd_std)
+
+          handle = FD_STD_MAP[fd_std][1]
+          @Out = WideConsole.new(handle)
+        end
+      end
+
+      $stdout = WideIO.new(:stdout)
+      $stderr = WideIO.new(:stderr)
+    rescue LoadError
+      def console_has_color?
+        false
+      end
+    else
+      def console_has_color?
+        true
+      end
+    end
+  else
+    # On a posix system we can just enable it
+    def console_has_color?
+      true
+    end
+  end
+
+  def colorize(color, str)
+    case Puppet[:color]
+    when true, :ansi, "ansi", "yes"
+      if console_has_color?
+        console_color(color, str)
+      else
+        str
+      end
+    when :html, "html"
+      html_color(color, str)
+    else
+      str
+    end
+  end
+
+  def console_color(color, str)
+    Colormap[color][:console] +
+    str.gsub(RESET[:console], Colormap[color][:console]) +
+    RESET[:console]
+  end
+
+  def html_color(color, str)
+    span = '<span style="%s">' % Colormap[color][:html]
+    "#{span}%s</span>" % str.gsub(/<span .*?<\/span>/, "</span>\\0#{span}")
+  end
+end