bolt 0.19.1 → 0.20.0

data/vendored/puppet/lib/puppet/util/classgen.rb

@@ -1,228 +0,0 @@
-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
-
-  # @api private
-  #
-  def is_constant_defined?(const)
-    const_defined?(const, false)
-  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 %{klass}") % { name: name, klass: self }
-        remove_const(const)
-      else
-        raise Puppet::ConstantAlreadyDefined,
-          _("Class %{const} is already defined in %{klass}") % { const: const, klass: 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}") % { klassname: 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}") % { klassname: klassname }
-      end
-
-      array << klass
-    end
-  end
-end
-

data/vendored/puppet/lib/puppet/util/colors.rb

@@ -1,100 +0,0 @@
-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 => "" }
-  }
-
-  def colorize(color, str)
-    case Puppet[:color]
-    when true, :ansi, "ansi", "yes"
-        console_color(color, str)
-    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

data/vendored/puppet/lib/puppet/util/command_line.rb

@@ -1,190 +0,0 @@
-# Bundler and rubygems maintain a set of directories from which to
-# load gems. If Bundler is loaded, let it determine what can be
-# loaded. If it's not loaded, then use rubygems. But do this before
-# loading any puppet code, so that our gem loading system is sane.
-if not defined? ::Bundler
-  begin
-    require 'rubygems'
-  rescue LoadError
-  end
-end
-
-require 'puppet'
-require 'puppet/util'
-require "puppet/util/rubygems"
-require "puppet/util/limits"
-require 'puppet/util/colors'
-require 'puppet/gettext/module_translations'
-
-module Puppet
-  module Util
-    # This is the main entry point for all puppet applications / faces; it
-    # is basically where the bootstrapping process / lifecycle of an app
-    # begins.
-    class CommandLine
-      include Puppet::Util::Limits
-
-      OPTION_OR_MANIFEST_FILE = /^-|\.pp$/
-
-      # @param zero [String] the name of the executable
-      # @param argv [Array<String>] the arguments passed on the command line
-      # @param stdin [IO] (unused)
-      def initialize(zero = $0, argv = ARGV, stdin = STDIN)
-        @command = File.basename(zero, '.rb')
-        @argv = argv
-      end
-
-      # @return [String] name of the subcommand is being executed
-      # @api public
-      def subcommand_name
-        return @command if @command != 'puppet'
-
-        if @argv.first =~ OPTION_OR_MANIFEST_FILE
-          nil
-        else
-          @argv.first
-        end
-      end
-
-      # @return [Array<String>] the command line arguments being passed to the subcommand
-      # @api public
-      def args
-        return @argv if @command != 'puppet'
-
-        if subcommand_name.nil?
-          @argv
-        else
-          @argv[1..-1]
-        end
-      end
-
-      # Run the puppet subcommand. If the subcommand is determined to be an
-      # external executable, this method will never return and the current
-      # process will be replaced via {Kernel#exec}.
-      #
-      # @return [void]
-      def execute
-        Puppet::Util.exit_on_fail(_("Could not initialize global default settings")) do
-          Puppet.initialize_settings(args)
-        end
-
-        setpriority(Puppet[:priority])
-
-        find_subcommand.run
-      end
-
-      # @api private
-      def external_subcommand
-        Puppet::Util.which("puppet-#{subcommand_name}")
-      end
-
-      private
-
-      def find_subcommand
-        if subcommand_name.nil?
-          if args.include?("--help") || args.include?("-h")
-            ApplicationSubcommand.new("help", CommandLine.new("puppet", ["help"]))
-          else
-            NilSubcommand.new(self)
-          end
-        elsif Puppet::Application.available_application_names.include?(subcommand_name)
-          ApplicationSubcommand.new(subcommand_name, self)
-        elsif path_to_subcommand = external_subcommand
-          ExternalSubcommand.new(path_to_subcommand, self)
-        else
-          UnknownSubcommand.new(subcommand_name, self)
-        end
-      end
-
-      # @api private
-      class ApplicationSubcommand
-        def initialize(subcommand_name, command_line)
-          @subcommand_name = subcommand_name
-          @command_line = command_line
-        end
-
-        def run
-          # For most applications, we want to be able to load code from the modulepath,
-          # such as apply, describe, resource, and faces.
-          # For agent, we only want to load pluginsync'ed code from libdir.
-          # For master, we shouldn't ever be loading per-environment code into the master's
-          # ruby process, but that requires fixing (#17210, #12173, #8750). So for now
-          # we try to restrict to only code that can be autoloaded from the node's
-          # environment.
-
-          # PUP-2114 - at this point in the bootstrapping process we do not
-          # have an appropriate application-wide current_environment set.
-          # If we cannot find the configured environment, which may not exist,
-          # we do not attempt to add plugin directories to the load path.
-          #
-          if @subcommand_name != 'master' and @subcommand_name != 'agent'
-            if configured_environment = Puppet.lookup(:environments).get(Puppet[:environment])
-              configured_environment.each_plugin_directory do |dir|
-                $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
-              end
-
-              Puppet::GettextConfig.reset_text_domain('cli')
-              Puppet::ModuleTranslations.load_from_modulepath(configured_environment.modules)
-              Puppet::ModuleTranslations.load_from_vardir(Puppet[:vardir])
-
-              # Puppet requires Facter, which initializes its lookup paths. Reset Facter to
-              # pickup the new $LOAD_PATH.
-              Facter.reset
-            end
-          end
-
-          app = Puppet::Application.find(@subcommand_name).new(@command_line)
-          app.run
-        end
-      end
-
-      # @api private
-      class ExternalSubcommand
-        def initialize(path_to_subcommand, command_line)
-          @path_to_subcommand = path_to_subcommand
-          @command_line = command_line
-        end
-
-        def run
-          Kernel.exec(@path_to_subcommand, *@command_line.args)
-        end
-      end
-
-      # @api private
-      class NilSubcommand
-        include Puppet::Util::Colors
-
-        def initialize(command_line)
-          @command_line = command_line
-        end
-
-        def run
-          args = @command_line.args
-          if args.include? "--version" or args.include? "-V"
-            puts Puppet.version
-          elsif @command_line.subcommand_name.nil? && args.count > 0
-            # If the subcommand is truly nil and there is an arg, it's an option; print out the invalid option message
-            puts colorize(:hred, _("Error: Could not parse application options: invalid option: %{opt}") % { opt: args[0] })
-            exit 1
-          else
-            puts _("See 'puppet help' for help on available puppet subcommands")
-          end
-        end
-      end
-
-      # @api private
-      class UnknownSubcommand < NilSubcommand
-        def initialize(subcommand_name, command_line)
-          @subcommand_name = subcommand_name
-          super(command_line)
-        end
-
-        def run
-          puts colorize(:hred, _("Error: Unknown Puppet subcommand '%{cmd}'") % { cmd: @subcommand_name })
-          super
-          exit 1
-        end
-      end
-    end
-  end
-end