bolt 0.24.0 → 0.25.0

data/vendored/puppet/lib/puppet/info_service.rb

@@ -1,17 +0,0 @@
-
-module Puppet::InfoService
-  require 'puppet/info_service/class_information_service'
-  require 'puppet/info_service/task_information_service'
-
-  def self.classes_per_environment(env_file_hash)
-    Puppet::InfoService::ClassInformationService.new.classes_per_environment(env_file_hash)
-  end
-
-  def self.tasks_per_environment(environment_name)
-    Puppet::InfoService::TaskInformationService.tasks_per_environment(environment_name)
-  end
-
-  def self.task_data(environment_name, module_name, task_name)
-    Puppet::InfoService::TaskInformationService.task_data(environment_name, module_name, task_name)
-  end
-end

data/vendored/puppet/lib/puppet/info_service/class_information_service.rb

@@ -1,110 +0,0 @@
-require 'puppet'
-require 'puppet/pops'
-require 'puppet/pops/evaluator/json_strict_literal_evaluator'
-
-class Puppet::InfoService::ClassInformationService
-
-  def initialize
-    @file_to_result = {}
-    @parser = Puppet::Pops::Parser::EvaluatingParser.new()
-  end
-
-  def classes_per_environment(env_file_hash)
-    # In this version of puppet there is only one way to parse manifests, as feature switches per environment
-    # are added or removed, this logic needs to change to compute the result per environment with the correct
-    # feature flags in effect.
-
-    unless env_file_hash.is_a?(Hash)
-      raise ArgumentError, _('Given argument must be a Hash')
-    end
-
-    result = {}
-
-    # for each environment
-    #   for each file
-    #     if file already processed, use last result or error
-    #
-    env_file_hash.each do |env, files|
-      env_result = result[env] = {}
-      files.each do |f|
-        env_result[f] = result_of(f)
-      end
-    end
-    result
-  end
-
-  private
-
-  def type_parser
-    Puppet::Pops::Types::TypeParser.singleton
-  end
-
-  def literal_evaluator
-    @@literal_evaluator ||= Puppet::Pops::Evaluator::JsonStrictLiteralEvaluator.new
-  end
-
-  def result_of(f)
-    entry =  @file_to_result[f]
-    if entry.nil?
-      @file_to_result[f] = entry = parse_file(f)
-    end
-    entry
-  end
-
-  def parse_file(f)
-    return {:error => _("The file %{f} does not exist") % { f: f }} unless Puppet::FileSystem.exist?(f)
-
-    begin
-      parse_result = @parser.parse_file(f)
-      {:classes =>
-        parse_result.definitions.select {|d| d.is_a?(Puppet::Pops::Model::HostClassDefinition)}.map do |d|
-          {:name   => d.name,
-           :params => d.parameters.map {|p| extract_param(p) }
-          }
-        end
-      }
-    rescue StandardError => e
-      {:error => e.message }
-    end
-  end
-
-  def extract_param(p)
-    extract_default(extract_type({:name => p.name}, p), p)
-  end
-
-  def extract_type(structure, p)
-    return structure if p.type_expr.nil?
-    structure[:type] = typeexpr_to_string(p.type_expr)
-    structure
-  end
-
-  def extract_default(structure, p)
-    value_expr = p.value
-    return structure if value_expr.nil?
-    default_value = value_as_literal(value_expr)
-    structure[:default_literal] = default_value unless default_value.nil?
-    structure[:default_source] = extract_value_source(value_expr)
-    structure
-  end
-
-  def typeexpr_to_string(type_expr)
-    begin
-      type_parser.interpret_any(type_expr, nil).to_s
-    rescue Puppet::ParseError
-      # type is to complex - contains expressions that are not literal
-      nil
-    end
-  end
-
-  def value_as_literal(value_expr)
-    catch(:not_literal) do
-      return literal_evaluator.literal(value_expr)
-    end
-    nil
-  end
-
-  # Extracts the source for the expression
-  def extract_value_source(value_expr)
-    value_expr.locator.extract_tree_text(value_expr)
-  end
-end

data/vendored/puppet/lib/puppet/info_service/task_information_service.rb

@@ -1,36 +0,0 @@
-class Puppet::InfoService::TaskInformationService
-  require 'puppet/module'
-
-  def self.tasks_per_environment(environment_name)
-    # get the actual environment object, raise error if the named env doesn't exist
-    env = Puppet.lookup(:environments).get!(environment_name)
-    env.modules.map do |mod|
-      mod.tasks.map do |task|
-        {:module => {:name => task.module.name}, :name => task.name}
-      end
-    end.flatten
-  end
-
-  def self.task_data(environment_name, module_name, task_name)
-    # raise EnvironmentNotFound if applicable
-    Puppet.lookup(:environments).get!(environment_name)
-
-    pup_module = Puppet::Module.find(module_name, environment_name)
-    if pup_module.nil?
-      raise Puppet::Module::MissingModule, _("Module %{module_name} not found in environment %{environment_name}.") %
-                                            {module_name: module_name, environment_name: environment_name}
-    end
-
-    task = pup_module.tasks.find { |t| t.name == task_name }
-    if task.nil?
-      raise Puppet::Module::Task::TaskNotFound.new(task_name, module_name)
-    end
-
-    begin
-      task.validate
-      {:metadata => task.metadata, :files => task.files}
-    rescue Puppet::Module::Task::Error => err
-      { :metadata => nil, :files => [], :error => err.to_h }
-    end
-  end
-end

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

@@ -1,237 +0,0 @@
-require 'puppet'
-require 'puppet/util/autoload'
-require 'prettyprint'
-
-# @api public
-class Puppet::Interface
-  require 'puppet/interface/documentation'
-  require 'puppet/interface/face_collection'
-
-  require 'puppet/interface/action'
-  require 'puppet/interface/action_builder'
-  require 'puppet/interface/action_manager'
-
-  require 'puppet/interface/option'
-  require 'puppet/interface/option_builder'
-  require 'puppet/interface/option_manager'
-
-
-  include FullDocs
-
-  include Puppet::Interface::ActionManager
-  extend Puppet::Interface::ActionManager
-
-  include Puppet::Interface::OptionManager
-  extend Puppet::Interface::OptionManager
-
-  include Puppet::Util
-
-  class << self
-    # This is just so we can search for actions.  We only use its
-    # list of directories to search.
-
-    # Lists all loaded faces
-    # @return [Array<Symbol>] The names of the loaded faces
-    def faces
-      Puppet::Interface::FaceCollection.faces
-    end
-
-    # Register a face
-    # @param instance [Puppet::Interface] The face
-    # @return [void]
-    # @api private
-    def register(instance)
-      Puppet::Interface::FaceCollection.register(instance)
-    end
-
-    # Defines a new Face.
-    # @todo Talk about using Faces DSL inside the block
-    #
-    # @param name [Symbol] the name of the face
-    # @param version [String] the version of the face (this should
-    #   conform to {http://semver.org/ Semantic Versioning})
-    # @overload define(name, version, {|| ... })
-    # @return [Puppet::Interface] The created face
-    # @api public
-    # @dsl Faces
-    def define(name, version, &block)
-      face = Puppet::Interface::FaceCollection[name, version]
-      if face.nil? then
-        face = self.new(name, version)
-        Puppet::Interface::FaceCollection.register(face)
-        # REVISIT: Shouldn't this be delayed until *after* we evaluate the
-        # current block, not done before? --daniel 2011-04-07
-        face.load_actions
-      end
-
-      face.instance_eval(&block) if block_given?
-
-      return face
-    end
-
-    # Retrieves a face by name and version. Use `:current` for the
-    # version to get the most recent available version.
-    #
-    # @param name [Symbol] the name of the face
-    # @param version [String, :current] the version of the face
-    #
-    # @return [Puppet::Interface] the face
-    #
-    # @api public
-    def face?(name, version)
-      Puppet::Interface::FaceCollection[name, version]
-    end
-
-    # Retrieves a face by name and version
-    #
-    # @param name [Symbol] the name of the face
-    # @param version [String] the version of the face
-    #
-    # @return [Puppet::Interface] the face
-    #
-    # @api public
-    def [](name, version)
-      unless face = Puppet::Interface::FaceCollection[name, version]
-        # REVISIT (#18042) no sense in rechecking if version == :current -- josh
-        if Puppet::Interface::FaceCollection[name, :current]
-          raise Puppet::Error, "Could not find version #{version} of #{name}"
-        else
-          raise Puppet::Error, "Could not find Puppet Face #{name.to_s}"
-        end
-      end
-
-      face
-    end
-
-    # Retrieves an action for a face
-    # @param name [Symbol] The face
-    # @param action [Symbol] The action name
-    # @param version [String, :current] The version of the face
-    # @return [Puppet::Interface::Action] The action
-    def find_action(name, action, version = :current)
-      Puppet::Interface::FaceCollection.get_action_for_face(name, action, version)
-    end
-  end
-
-  ########################################################################
-  # Documentation.  We currently have to rewrite both getters because we share
-  # the same instance between build-time and the runtime instance.  When that
-  # splits out this should merge into a module that both the action and face
-  # include. --daniel 2011-04-17
-
-
-  # Returns the synopsis for the face. This shows basic usage and global
-  # options.
-  # @return [String] usage synopsis
-  # @api private
-  def synopsis
-    build_synopsis self.name, '<action>'
-  end
-
-
-  ########################################################################
-
-  # The name of the face
-  # @return [Symbol]
-  # @api private
-  attr_reader :name
-
-  # The version of the face
-  # @return [SemanticPuppet::Version]
-  attr_reader :version
-
-  # The autoloader instance for the face
-  # @return [Puppet::Util::Autoload]
-  # @api private
-  attr_reader :loader
-  private :loader
-
-  # @api private
-  def initialize(name, version, &block)
-    unless SemanticPuppet::Version.valid?(version)
-      raise ArgumentError, _("Cannot create face %{name} with invalid version number '%{version}'!") % { name: name.inspect, version: version }
-    end
-
-    @name    = Puppet::Interface::FaceCollection.underscorize(name)
-    @version = SemanticPuppet::Version.parse(version)
-
-    # The few bits of documentation we actually demand.  The default license
-    # is a favour to our end users; if you happen to get that in a core face
-    # report it as a bug, please. --daniel 2011-04-26
-    @authors  = []
-    @license  = 'All Rights Reserved'
-
-    @loader = Puppet::Util::Autoload.new(@name, "puppet/face/#{@name}")
-    instance_eval(&block) if block_given?
-  end
-
-  # Loads all actions defined in other files.
-  #
-  # @return [void]
-  # @api private
-  def load_actions
-    loader.loadall(Puppet.lookup(:current_environment))
-  end
-
-  # Returns a string representation with the face's name and version
-  # @return [String]
-  def to_s
-    "Puppet::Face[#{name.inspect}, #{version.inspect}]"
-  end
-  alias_method :inspect, :to_s
-
-  # @return [void]
-  def deprecate
-    @deprecated = true
-  end
-
-  # @return [Boolean]
-  def deprecated?
-    @deprecated
-  end
-  ########################################################################
-  # Action decoration, whee!  You are not expected to care about this code,
-  # which exists to support face building and construction.  I marked these
-  # private because the implementation is crude and ugly, and I don't yet know
-  # enough to work out how to make it clean.
-  #
-  # Once we have established that these methods will likely change radically,
-  # to be unrecognizable in the final outcome.  At which point we will throw
-  # all this away, replace it with something nice, and work out if we should
-  # be making this visible to the outside world... --daniel 2011-04-14
-  private
-  # @return [void]
-  # @api private
-  def __invoke_decorations(type, action, passed_args = [], passed_options = {})
-    [:before, :after].member?(type) or fail "unknown decoration type #{type}"
-
-    # Collect the decoration methods matching our pass.
-    methods = action.options.select do |name|
-      passed_options.has_key? name
-    end.map do |name|
-      action.get_option(name).__decoration_name(type)
-    end
-
-    methods.reverse! if type == :after
-
-    # Exceptions here should propagate up; this implements a hook we can use
-    # reasonably for option validation.
-    methods.each do |hook|
-      respond_to? hook and self.__send__(hook, action, passed_args, passed_options)
-    end
-  end
-
-  # @return [void]
-  # @api private
-  def __add_method(name, proc)
-    meta_def(name, &proc)
-    method(name).unbind
-  end
-
-  # @return [void]
-  # @api private
-  def self.__add_method(name, proc)
-    define_method(name, proc)
-    instance_method(name)
-  end
-end

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

@@ -1,399 +0,0 @@
-# coding: utf-8
-require 'prettyprint'
-
-# This represents an action that is attached to a face. Actions should
-# be constructed by calling {Puppet::Interface::ActionManager#action},
-# which is available on {Puppet::Interface}, and then calling methods of
-# {Puppet::Interface::ActionBuilder} in the supplied block.
-# @api private
-class Puppet::Interface::Action
-  extend  Puppet::Interface::DocGen
-  include Puppet::Interface::FullDocs
-
-  # @api private
-  def initialize(face, name)
-    raise "#{name.inspect} is an invalid action name" unless name.to_s =~ /^[a-z]\w*$/
-    @face    = face
-    @name    = name.to_sym
-
-    # The few bits of documentation we actually demand.  The default license
-    # is a favour to our end users; if you happen to get that in a core face
-    # report it as a bug, please. --daniel 2011-04-26
-    @authors = []
-    @license  = 'All Rights Reserved'
-
-    # @options collects the added options in the order they're declared.
-    # @options_hash collects the options keyed by alias for quick lookups.
-    @options        = []
-    @display_global_options = []
-    @options_hash   = {}
-    @when_rendering = {}
-  end
-
-  # This is not nice, but it is the easiest way to make us behave like the
-  # Ruby Method object rather than UnboundMethod.  Duplication is vaguely
-  # annoying, but at least we are a shallow clone. --daniel 2011-04-12
-
-  # @return [void]
-  # @api private
-  def __dup_and_rebind_to(to)
-    bound_version = self.dup
-    bound_version.instance_variable_set(:@face, to)
-    return bound_version
-  end
-
-  def to_s() "#{@face}##{@name}" end
-
-  # The name of this action
-  # @return [Symbol]
-  attr_reader   :name
-
-  # The face this action is attached to
-  # @return [Puppet::Interface]
-  attr_reader   :face
-
-  # Whether this is the default action for the face
-  # @return [Boolean]
-  # @api private
-  attr_accessor :default
-  def default?
-    !!@default
-  end
-
-  ########################################################################
-  # Documentation...
-  attr_doc :returns
-  attr_doc :arguments
-  def synopsis
-    build_synopsis(@face.name, default? ? nil : name, arguments)
-  end
-
-  ########################################################################
-  # Support for rendering formats and all.
-
-
-  # @api private
-  def when_rendering(type)
-    unless type.is_a? Symbol
-      raise ArgumentError, _("The rendering format must be a symbol, not %{class_name}") % { class_name: type.class.name }
-    end
-    # Do we have a rendering hook for this name?
-    return @when_rendering[type].bind(@face) if @when_rendering.has_key? type
-
-    # How about by another name?
-    alt = type.to_s.sub(/^to_/, '').to_sym
-    return @when_rendering[alt].bind(@face) if @when_rendering.has_key? alt
-
-    # Guess not, nothing to run.
-    return nil
-  end
-
-  # @api private
-  def set_rendering_method_for(type, proc)
-    unless proc.is_a? Proc
-      msg = if proc.nil?
-              #TRANSLATORS 'set_rendering_method_for' and 'Proc' should not be translated
-              _("The second argument to set_rendering_method_for must be a Proc")
-            else
-              #TRANSLATORS 'set_rendering_method_for' and 'Proc' should not be translated
-              _("The second argument to set_rendering_method_for must be a Proc, not %{class_name}") %
-                  { class_name: proc.class.name }
-            end
-      raise ArgumentError, msg
-    end
-
-    if proc.arity != 1 and proc.arity != (@positional_arg_count + 1)
-      msg = if proc.arity < 0 then
-              #TRANSLATORS 'when_rendering', 'when_invoked' are method names and should not be translated
-              _("The when_rendering method for the %{face} face %{name} action takes either just one argument,"\
-                  " the result of when_invoked, or the result plus the %{arg_count} arguments passed to the"\
-                  " when_invoked block, not a variable number") %
-                  { face: @face.name, name: name, arg_count: @positional_arg_count }
-            else
-              #TRANSLATORS 'when_rendering', 'when_invoked' are method names and should not be translated
-              _("The when_rendering method for the %{face} face %{name} action takes either just one argument,"\
-                  " the result of when_invoked, or the result plus the %{arg_count} arguments passed to the"\
-                  " when_invoked block, not %{string}") %
-                  { face: @face.name, name: name, arg_count: @positional_arg_count, string: proc.arity.to_s }
-            end
-      raise ArgumentError, msg
-    end
-    unless type.is_a? Symbol
-      raise ArgumentError, _("The rendering format must be a symbol, not %{class_name}") % { class_name: type.class.name }
-    end
-    if @when_rendering.has_key? type then
-      raise ArgumentError, _("You can't define a rendering method for %{type} twice") % { type: type }
-    end
-    # Now, the ugly bit.  We add the method to our interface object, and
-    # retrieve it, to rotate through the dance of getting a suitable method
-    # object out of the whole process. --daniel 2011-04-18
-    @when_rendering[type] =
-      @face.__send__( :__add_method, __render_method_name_for(type), proc)
-  end
-
-  # @return [void]
-  # @api private
-  def __render_method_name_for(type)
-    :"#{name}_when_rendering_#{type}"
-  end
-  private :__render_method_name_for
-
-
-  # @api private
-  # @return [Symbol]
-  attr_accessor :render_as
-  def render_as=(value)
-    @render_as = value.to_sym
-  end
-
-  # @api private
-  # @return [void]
-  def deprecate
-    @deprecated = true
-  end
-
-  # @api private
-  # @return [Boolean]
-  def deprecated?
-    @deprecated
-  end
-
-  ########################################################################
-  # Initially, this was defined to allow the @action.invoke pattern, which is
-  # a very natural way to invoke behaviour given our introspection
-  # capabilities.   Heck, our initial plan was to have the faces delegate to
-  # the action object for invocation and all.
-  #
-  # It turns out that we have a binding problem to solve: @face was bound to
-  # the parent class, not the subclass instance, and we don't pass the
-  # appropriate context or change the binding enough to make this work.
-  #
-  # We could hack around it, by either mandating that you pass the context in
-  # to invoke, or try to get the binding right, but that has probably got
-  # subtleties that we don't instantly think of – especially around threads.
-  #
-  # So, we are pulling this method for now, and will return it to life when we
-  # have the time to resolve the problem.  For now, you should replace...
-  #
-  #     @action = @face.get_action(name)
-  #     @action.invoke(arg1, arg2, arg3)
-  #
-  # ...with...
-  #
-  #     @action = @face.get_action(name)
-  #     @face.send(@action.name, arg1, arg2, arg3)
-  #
-  # I understand that is somewhat cumbersome, but it functions as desired.
-  # --daniel 2011-03-31
-  #
-  # PS: This code is left present, but commented, to support this chunk of
-  # documentation, for the benefit of the reader.
-  #
-  # def invoke(*args, &block)
-  #   @face.send(name, *args, &block)
-  # end
-
-
-  # We need to build an instance method as a wrapper, using normal code, to be
-  # able to expose argument defaulting between the caller and definer in the
-  # Ruby API.  An extra method is, sadly, required for Ruby 1.8 to work since
-  # it doesn't expose bind on a block.
-  #
-  # Hopefully we can improve this when we finally shuffle off the last of Ruby
-  # 1.8 support, but that looks to be a few "enterprise" release eras away, so
-  # we are pretty stuck with this for now.
-  #
-  # Patches to make this work more nicely with Ruby 1.9 using runtime version
-  # checking and all are welcome, provided that they don't change anything
-  # outside this little ol' bit of code and all.
-  #
-  # Incidentally, we though about vendoring evil-ruby and actually adjusting
-  # the internal C structure implementation details under the hood to make
-  # this stuff work, because it would have been cleaner.  Which gives you an
-  # idea how motivated we were to make this cleaner.  Sorry.
-  # --daniel 2011-03-31
-
-
-  # The arity of the action
-  # @return [Integer]
-  attr_reader   :positional_arg_count
-
-  # The block that is executed when the action is invoked
-  # @return [block]
-  attr_accessor :when_invoked
-  def when_invoked=(block)
-
-    internal_name = "#{@name} implementation, required on Ruby 1.8".to_sym
-
-    arity = @positional_arg_count = block.arity
-    if arity == 0 then
-      # This will never fire on 1.8.7, which treats no arguments as "*args",
-      # but will on 1.9.2, which treats it as "no arguments".  Which bites,
-      # because this just begs for us to wind up in the horrible situation
-      # where a 1.8 vs 1.9 error bites our end users. --daniel 2011-04-19
-      #TRANSLATORS 'when_invoked' should not be translated
-      raise ArgumentError, _("when_invoked requires at least one argument (options) for action %{name}") % { name: @name }
-    elsif arity > 0 then
-      range = Range.new(1, arity - 1)
-      decl = range.map { |x| "arg#{x}" } << "options = {}"
-      optn = ""
-      args = "[" + (range.map { |x| "arg#{x}" } << "options").join(", ") + "]"
-    else
-      range = Range.new(1, arity.abs - 1)
-      decl = range.map { |x| "arg#{x}" } << "*rest"
-      optn = "rest << {} unless rest.last.is_a?(Hash)"
-      if arity == -1 then
-        args = "rest"
-      else
-        args = "[" + range.map { |x| "arg#{x}" }.join(", ") + "] + rest"
-      end
-    end
-
-    file    = __FILE__ + "+eval[wrapper]"
-    line    = __LINE__ + 2 # <== points to the same line as 'def' in the wrapper.
-    wrapper = <<WRAPPER
-def #{@name}(#{decl.join(", ")})
-  #{optn}
-  args    = #{args}
-  action  = get_action(#{name.inspect})
-  args   << action.validate_and_clean(args.pop)
-  __invoke_decorations(:before, action, args, args.last)
-  rval = self.__send__(#{internal_name.inspect}, *args)
-  __invoke_decorations(:after, action, args, args.last)
-  return rval
-end
-WRAPPER
-
-    if @face.is_a?(Class)
-      @face.class_eval do eval wrapper, nil, file, line end
-      @face.send(:define_method, internal_name, &block)
-      @when_invoked = @face.instance_method(name)
-    else
-      @face.instance_eval do eval wrapper, nil, file, line end
-      @face.meta_def(internal_name, &block)
-      @when_invoked = @face.method(name).unbind
-    end
-  end
-
-  def add_option(option)
-    option.aliases.each do |name|
-      if conflict = get_option(name) then
-        raise ArgumentError, _("Option %{option} conflicts with existing option %{conflict}") %
-            { option: option, conflict: conflict }
-      elsif conflict = @face.get_option(name) then
-        raise ArgumentError, _("Option %{option} conflicts with existing option %{conflict} on %{face}") %
-            { option: option, conflict: conflict, face: @face }
-      end
-    end
-
-    @options << option.name
-
-    option.aliases.each do |name|
-      @options_hash[name] = option
-    end
-
-    option
-  end
-
-  def option?(name)
-    @options_hash.include? name.to_sym
-  end
-
-  def options
-    @face.options + @options
-  end
-
-  def add_display_global_options(*args)
-    @display_global_options ||= []
-    [args].flatten.each do |refopt|
-      unless Puppet.settings.include? refopt
-        #TRANSLATORS 'Puppet.settings' should not be translated
-        raise ArgumentError, _("Global option %{option} does not exist in Puppet.settings") % { option: refopt }
-      end
-      @display_global_options << refopt
-    end
-    @display_global_options.uniq!
-    @display_global_options
-  end
-
-  def display_global_options(*args)
-    args ? add_display_global_options(args) : @display_global_options + @face.display_global_options
-  end
-  alias :display_global_option :display_global_options
-
-  def get_option(name, with_inherited_options = true)
-    option = @options_hash[name.to_sym]
-    if option.nil? and with_inherited_options
-      option = @face.get_option(name)
-    end
-    option
-  end
-
-  def validate_and_clean(original)
-    # The final set of arguments; effectively a hand-rolled shallow copy of
-    # the original, which protects the caller from the surprises they might
-    # get if they passed us a hash and we mutated it...
-    result = {}
-
-    # Check for multiple aliases for the same option, and canonicalize the
-    # name of the argument while we are about it.
-    overlap = Hash.new do |h, k| h[k] = [] end
-    unknown = []
-    original.keys.each do |name|
-      if option = get_option(name) then
-        canonical = option.name
-        if result.has_key? canonical
-          overlap[canonical] << name
-        else
-          result[canonical] = original[name]
-        end
-      elsif Puppet.settings.include? name
-        result[name] = original[name]
-      else
-        unknown << name
-      end
-    end
-
-    unless overlap.empty?
-      overlap_list = overlap.map {|k, v| "(#{k}, #{v.sort.join(', ')})" }.join(", ")
-      raise ArgumentError, _("Multiple aliases for the same option passed: %{overlap_list}") %
-          { overlap_list: overlap_list }
-    end
-
-    unless unknown.empty?
-      unknown_list = unknown.sort.join(", ")
-      raise ArgumentError, _("Unknown options passed: %{unknown_list}") % { unknown_list: unknown_list }
-    end
-
-    # Inject default arguments and check for missing mandating options.
-    missing = []
-    options.map {|x| get_option(x) }.each do |option|
-      name = option.name
-      next if result.has_key? name
-
-      if option.has_default?
-        result[name] = option.default
-      elsif option.required?
-        missing << name
-      end
-    end
-
-    unless missing.empty?
-      missing_list = missing.sort.join(', ')
-      raise ArgumentError, _("The following options are required: %{missing_list}") % { missing_list: missing_list }
-    end
-
-    # All done.
-    return result
-  end
-
-  ########################################################################
-  # Support code for action decoration; see puppet/interface.rb for the gory
-  # details of why this is hidden away behind private. --daniel 2011-04-15
-  private
-  # @return [void]
-  # @api private
-  def __add_method(name, proc)
-    @face.__send__ :__add_method, name, proc
-  end
-end