bolt 0.24.0 → 0.25.0

data/vendored/puppet/lib/puppet/interface/face_collection.rb

@@ -1,134 +0,0 @@
-module Puppet::Interface::FaceCollection
-  @faces = Hash.new { |hash, key| hash[key] = {} }
-
-  @loader = Puppet::Util::Autoload.new(:application, 'puppet/face')
-
-  def self.faces
-    unless @loaded
-      @loaded = true
-      names = @loader.files_to_load(Puppet.lookup(:current_environment)).map do |fn|
-        ::File.basename(fn, '.rb')
-      end.uniq
-      names.each {|name| self[name, :current]}
-    end
-    @faces.keys.select {|name| @faces[name].length > 0 }
-  end
-
-  def self.[](name, version)
-    name = underscorize(name)
-    get_face(name, version) or load_face(name, version)
-  end
-
-  def self.get_action_for_face(name, action_name, version)
-    name = underscorize(name)
-
-    # If the version they request specifically doesn't exist, don't search
-    # elsewhere.  Usually this will start from :current and all...
-    return nil unless face = self[name, version]
-    unless action = face.get_action(action_name)
-      # ...we need to search for it bound to an o{lder,ther} version.  Since
-      # we load all actions when the face is first references, this will be in
-      # memory in the known set of versions of the face.
-      (@faces[name].keys - [ :current ]).sort.reverse_each do |vers|
-        break if action = @faces[name][vers].get_action(action_name)
-      end
-    end
-
-    return action
-  end
-
-  # get face from memory, without loading.
-  def self.get_face(name, pattern)
-    return nil unless @faces.has_key? name
-    return @faces[name][:current] if pattern == :current
-
-    versions = @faces[name].keys - [ :current ]
-    range = pattern.is_a?(SemanticPuppet::Version) ? SemanticPuppet::VersionRange.new(pattern, pattern) : SemanticPuppet::VersionRange.parse(pattern)
-    found = find_matching(range, versions)
-    return @faces[name][found]
-  end
-
-  def self.find_matching(range, versions)
-    versions.select { |v| range === v }.sort.last
-  end
-
-  # try to load the face, and return it.
-  def self.load_face(name, version)
-    # We always load the current version file; the common case is that we have
-    # the expected version and any compatibility versions in the same file,
-    # the default.  Which means that this is almost always the case.
-    #
-    # We use require to avoid executing the code multiple times, like any
-    # other Ruby library that we might want to use.  --daniel 2011-04-06
-    if safely_require name then
-      # If we wanted :current, we need to index to find that; direct version
-      # requests just work as they go. --daniel 2011-04-06
-      if version == :current then
-        # We need to find current out of this.  This is the largest version
-        # number that doesn't have a dedicated on-disk file present; those
-        # represent "experimental" versions of faces, which we don't fully
-        # support yet.
-        #
-        # We walk the versions from highest to lowest and take the first version
-        # that is not defined in an explicitly versioned file on disk as the
-        # current version.
-        #
-        # This constrains us to only ship experimental versions with *one*
-        # version in the file, not multiple, but given you can't reliably load
-        # them except by side-effect when you ignore that rule this seems safe
-        # enough...
-        #
-        # Given those constraints, and that we are not going to ship a versioned
-        # interface that is not :current in this release, we are going to leave
-        # these thoughts in place, and just punt on the actual versioning.
-        #
-        # When we upgrade the core to support multiple versions we can solve the
-        # problems then; as lazy as possible.
-        #
-        # We do support multiple versions in the same file, though, so we sort
-        # versions here and return the last item in that set.
-        #
-        # --daniel 2011-04-06
-        latest_ver = @faces[name].keys.sort.last
-        @faces[name][:current] = @faces[name][latest_ver]
-      end
-    end
-
-    unless version == :current or get_face(name, version)
-      # Try an obsolete version of the face, if needed, to see if that helps?
-      safely_require name, version
-    end
-
-    return get_face(name, version)
-  end
-
-  def self.safely_require(name, version = nil)
-    path = @loader.expand(version ? ::File.join(version.to_s, name.to_s) : name)
-    require path
-    true
-
-  rescue LoadError => e
-    raise unless e.message =~ %r{-- #{path}$}
-    # ...guess we didn't find the file; return a much better problem.
-    nil
-  rescue SyntaxError => e
-    raise unless e.message =~ %r{#{path}\.rb:\d+: }
-    Puppet.err _("Failed to load face %{name}:\n%{detail}") % { name: name, detail: e }
-    # ...but we just carry on after complaining.
-    nil
-  end
-
-  def self.register(face)
-    @faces[underscorize(face.name)][face.version] = face
-  end
-
-  def self.underscorize(name)
-    unless name.to_s =~ /^[-_a-z][-_a-z0-9]*$/i then
-      #TRANSLATORS 'face' refers to a programming API in Puppet
-      raise ArgumentError, _("%{name} (%{class_name}) is not a valid face name") %
-          { name: name.inspect, class_name: name.class }
-    end
-
-    name.to_s.downcase.split(/[-_]/).join('_').to_sym
-  end
-end

data/vendored/puppet/lib/puppet/interface/option.rb

@@ -1,171 +0,0 @@
-# This represents an option on an action or face (to be globally applied
-# to its actions). Options should be constructed by calling
-# {Puppet::Interface::OptionManager#option}, which is available on
-# {Puppet::Interface}, and then calling methods of
-# {Puppet::Interface::OptionBuilder} in the supplied block.
-# @api public
-class Puppet::Interface::Option
-  include Puppet::Interface::TinyDocs
-
-  # @api private
-  def initialize(parent, *declaration, &block)
-    @parent   = parent
-    @optparse = []
-    @default  = nil
-
-    # Collect and sort the arguments in the declaration.
-    dups = {}
-    declaration.each do |item|
-      if item.is_a? String and item.to_s =~ /^-/ then
-        unless item =~ /^-[a-z]\b/ or item =~ /^--[^-]/ then
-          raise ArgumentError, _("%{option}: long options need two dashes (--)") % { option: item.inspect }
-        end
-        @optparse << item
-
-        # Duplicate checking...
-        # for our duplicate checking purpose, we don't make a check with the
-        # translated '-' -> '_'. Right now, we do that on purpose because of
-        # a duplicated option made publicly available on certificate and ca
-        # faces for dns alt names. Puppet defines 'dns_alt_names', those
-        # faces include 'dns-alt-names'.  We can't get rid of 'dns-alt-names'
-        # yet, so we need to do our duplicate checking on the untranslated
-        # version of the option.
-        # jeffweiss 17 april 2012
-        name = optparse_to_optionname(item)
-        if Puppet.settings.include? name then
-          raise ArgumentError, _("%{option}: already defined in puppet") % { option: item.inspect }
-        end
-        if dup = dups[name] then
-          raise ArgumentError, _("%{option}: duplicates existing alias %{duplicate} in %{parent}") %
-              { option: item.inspect, duplicate: dup.inspect, parent: @parent }
-        else
-          dups[name] = item
-        end
-      else
-        raise ArgumentError, _("%{option} is not valid for an option argument") % { option: item.inspect }
-      end
-    end
-
-    if @optparse.empty? then
-      raise ArgumentError, _("No option declarations found while building")
-    end
-
-    # Now, infer the name from the options; we prefer the first long option as
-    # the name, rather than just the first option.
-    @name = optparse_to_name(@optparse.find do |a| a =~ /^--/ end || @optparse.first)
-    @aliases = @optparse.map { |o| optparse_to_name(o) }
-
-    # Do we take an argument?  If so, are we consistent about it, because
-    # incoherence here makes our life super-difficult, and we can more easily
-    # relax this rule later if we find a valid use case for it. --daniel 2011-03-30
-    @argument = @optparse.any? { |o| o =~ /[ =]/ }
-    if @argument and not @optparse.all? { |o| o =~ /[ =]/ } then
-      raise ArgumentError, _("Option %{name} is inconsistent about taking an argument") % { name: @name }
-    end
-
-    # Is our argument optional?  The rules about consistency apply here, also,
-    # just like they do to taking arguments at all. --daniel 2011-03-30
-    @optional_argument = @optparse.any? { |o| o=~/[ =]\[/ }
-    if @optional_argument
-      raise ArgumentError, _("Options with optional arguments are not supported")
-    end
-    if @optional_argument and not @optparse.all? { |o| o=~/[ =]\[/ } then
-      raise ArgumentError, _("Option %{name} is inconsistent about the argument being optional") % { name: @name }
-    end
-  end
-
-  # to_s and optparse_to_name are roughly mirrored, because they are used to
-  # transform options to name symbols, and vice-versa.  This isn't a full
-  # bidirectional transformation though. --daniel 2011-04-07
-
-  def to_s
-    @name.to_s.tr('_', '-')
-  end
-
-  # @api private
-  def optparse_to_optionname(declaration)
-    unless found = declaration.match(/^-+(?:\[no-\])?([^ =]+)/) then
-      raise ArgumentError, _("Can't find a name in the declaration %{declaration}") % { declaration: declaration.inspect }
-    end
-    found.captures.first
-  end
-
-  # @api private
-  def optparse_to_name(declaration)
-    name = optparse_to_optionname(declaration).tr('-', '_')
-    unless name.to_s =~ /^[a-z]\w*$/
-      raise _("%{name} is an invalid option name") % { name: name.inspect }
-    end
-    name.to_sym
-  end
-
-
-  def takes_argument?
-    !!@argument
-  end
-  def optional_argument?
-    !!@optional_argument
-  end
-  def required?
-    !!@required
-  end
-
-  def has_default?
-    !!@default
-  end
-
-  def default=(proc)
-    if required
-      raise ArgumentError, _("%{name} can't be optional and have a default value") % { name: self }
-    end
-    unless proc.is_a? Proc
-      #TRANSLATORS 'proc' is a Ruby block of code
-      raise ArgumentError, _("default value for %{name} is a %{class_name}, not a proc") %
-          { name: self, class_name: proc.class.name.inspect }
-    end
-    @default = proc
-  end
-
-  def default
-    @default and @default.call
-  end
-
-  attr_reader   :parent, :name, :aliases, :optparse
-  attr_accessor :required
-  def required=(value)
-    if has_default?
-      raise ArgumentError, _("%{name} can't be optional and have a default value") % { name: self }
-    end
-    @required = value
-  end
-
-  attr_accessor :before_action
-  def before_action=(proc)
-    unless proc.is_a? Proc
-      #TRANSLATORS 'proc' is a Ruby block of code
-      raise ArgumentError, _("before action hook for %{name} is a %{class_name}, not a proc") %
-          { name: self, class_name: proc.class.name.inspect }
-    end
-    @before_action =
-      @parent.__send__(:__add_method, __decoration_name(:before), proc)
-  end
-
-  attr_accessor :after_action
-  def after_action=(proc)
-    unless proc.is_a? Proc
-      #TRANSLATORS 'proc' is a Ruby block of code
-      raise ArgumentError, _("after action hook for %{name} is a %{class_name}, not a proc") %
-          { name: self, class_name: proc.class.name.inspect }
-    end
-    @after_action =
-      @parent.__send__(:__add_method, __decoration_name(:after), proc)
-  end
-
-  def __decoration_name(type)
-    if @parent.is_a? Puppet::Interface::Action then
-      :"option #{name} from #{parent.name} #{type} decoration"
-    else
-      :"option #{name} #{type} decoration"
-    end
-  end
-end

data/vendored/puppet/lib/puppet/interface/option_builder.rb

@@ -1,105 +0,0 @@
-# @api public
-class Puppet::Interface::OptionBuilder
-  # The option under construction
-  # @return [Puppet::Interface::Option]
-  # @api private
-  attr_reader :option
-
-  # Build an option
-  # @return [Puppet::Interface::Option]
-  # @api private
-  def self.build(face, *declaration, &block)
-    new(face, *declaration, &block).option
-  end
-
-  def initialize(face, *declaration, &block)
-    @face   = face
-    @option = Puppet::Interface::Option.new(face, *declaration)
-    instance_eval(&block) if block_given?
-    @option
-  end
-
-  # Metaprogram the simple DSL from the option class.
-  Puppet::Interface::Option.instance_methods.grep(/=$/).each do |setter|
-    next if setter =~ /^=/
-    dsl = setter.to_s.chomp('=')
-
-    unless private_method_defined? dsl
-      define_method(dsl) do |value| @option.send(setter, value) end
-    end
-  end
-
-  # Override some methods that deal in blocks, not objects.
-
-  # Sets a block to be executed when an action is invoked before the
-  # main action code. This is most commonly used to validate an option.
-  # @yieldparam action [Puppet::Interface::Action] The action being
-  #   invoked
-  # @yieldparam args [Array] The arguments given to the action
-  # @yieldparam options [Hash<Symbol=>Object>] Any options set
-  # @api public
-  # @dsl Faces
-  def before_action(&block)
-    unless block
-      #TRANSLATORS 'before_action' is a method name and should not be translated
-      raise ArgumentError, _("%{option} before_action requires a block") % { option: @option }
-    end
-    if @option.before_action
-      #TRANSLATORS 'before_action' is a method name and should not be translated
-      raise ArgumentError, _("%{option} already has a before_action set") % { option: @option }
-    end
-    unless block.arity == 3 then
-      #TRANSLATORS 'before_action' is a method name and should not be translated
-      raise ArgumentError, _("before_action takes three arguments, action, args, and options")
-    end
-    @option.before_action = block
-  end
-
-  # Sets a block to be executed after an action is invoked.
-  # !(see before_action)
-  # @api public
-  # @dsl Faces
-  def after_action(&block)
-    unless block
-      #TRANSLATORS 'after_action' is a method name and should not be translated
-      raise ArgumentError, _("%{option} after_action requires a block") % { option: @option }
-    end
-    if @option.after_action
-      #TRANSLATORS 'after_action' is a method name and should not be translated
-      raise ArgumentError, _("%{option} already has an after_action set") % { option: @option }
-    end
-    unless block.arity == 3 then
-      #TRANSLATORS 'after_action' is a method name and should not be translated
-      raise ArgumentError, _("after_action takes three arguments, action, args, and options")
-    end
-    @option.after_action = block
-  end
-
-  # Sets whether the option is required. If no argument is given it
-  # defaults to setting it as a required option.
-  # @api public
-  # @dsl Faces
-  def required(value = true)
-    @option.required = value
-  end
-
-  # Sets a block that will be used to compute the default value for this
-  # option. It will be evaluated when the action is invoked. The block
-  # should take no arguments.
-  # @api public
-  # @dsl Faces
-  def default_to(&block)
-    unless block
-      #TRANSLATORS 'default_to' is a method name and should not be translated
-      raise ArgumentError, _("%{option} default_to requires a block") % { option: @option }
-    end
-    if @option.has_default?
-      raise ArgumentError, _("%{option} already has a default value") % { option: @option }
-    end
-    unless block.arity == 0
-      #TRANSLATORS 'default_to' is a method name and should not be translated
-      raise ArgumentError, _("%{option} default_to block should not take any arguments") % { option: @option }
-    end
-    @option.default = block
-  end
-end

data/vendored/puppet/lib/puppet/interface/option_manager.rb

@@ -1,104 +0,0 @@
-# This class is not actually public API, but the method
-# {Puppet::Interface::OptionManager#option option} is public when used
-# as part of the Faces DSL (i.e. from within a
-# {Puppet::Interface.define define} block).
-# @api public
-module Puppet::Interface::OptionManager
-
-  # @api private
-  def display_global_options(*args)
-    @display_global_options ||= []
-    [args].flatten.each do |refopt|
-      unless Puppet.settings.include?(refopt)
-        #TRANSLATORS 'Puppet.settings' references to the Puppet settings options and should not be translated
-        raise ArgumentError, _("Global option %{option} does not exist in Puppet.settings") % { option: refopt }
-      end
-      @display_global_options << refopt if refopt
-    end
-    @display_global_options.uniq!
-    @display_global_options
-  end
-  alias :display_global_option :display_global_options
-
-  def all_display_global_options
-    walk_inheritance_tree(@display_global_options, :all_display_global_options)
-  end
-
-  # @api private
-  def walk_inheritance_tree(start, sym)
-    result = (start || [])
-    if self.is_a?(Class) and superclass.respond_to?(sym)
-      result = superclass.send(sym) + result
-    elsif self.class.respond_to?(sym)
-      result = self.class.send(sym) + result
-    end
-    return result
-  end
-
-  # Declare that this app can take a specific option, and provide the
-  # code to do so. See {Puppet::Interface::ActionBuilder#option} for
-  # details.
-  #
-  # @api public
-  # @dsl Faces
-  def option(*declaration, &block)
-    add_option Puppet::Interface::OptionBuilder.build(self, *declaration, &block)
-  end
-
-  # @api private
-  def add_option(option)
-    # @options collects the added options in the order they're declared.
-    # @options_hash collects the options keyed by alias for quick lookups.
-    @options      ||= []
-    @options_hash ||= {}
-
-    option.aliases.each do |name|
-      if conflict = get_option(name) then
-        raise ArgumentError, _("Option %{option} conflicts with existing option %{conflict}") %
-            { option: option, conflict: conflict }
-      end
-
-      actions.each do |action|
-        action = get_action(action)
-        if conflict = action.get_option(name) then
-          raise ArgumentError, _("Option %{option} conflicts with existing option %{conflict} on %{action}") %
-              { option: option, conflict: conflict, action: action }
-        end
-      end
-    end
-
-    @options << option.name
-
-    option.aliases.each do |name|
-      @options_hash[name] = option
-    end
-
-    return option
-  end
-
-  # @api private
-  def options
-    walk_inheritance_tree(@options, :options)
-  end
-
-  # @api private
-  def get_option(name, with_inherited_options = true)
-    @options_hash ||= {}
-
-    result = @options_hash[name.to_sym]
-    if result.nil? and with_inherited_options then
-      if self.is_a?(Class) and superclass.respond_to?(:get_option)
-        result = superclass.get_option(name)
-      elsif self.class.respond_to?(:get_option)
-        result = self.class.get_option(name)
-      end
-    end
-
-    return result
-  end
-
-  # @api private
-  def option?(name)
-    options.include? name.to_sym
-  end
-end