openvox 7.37.1

data/lib/puppet/interface/option_builder.rb

@@ -0,0 +1,105 @@
+# @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/lib/puppet/interface/option_manager.rb

@@ -0,0 +1,106 @@
+# 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|
+      conflict = get_option(name)
+      if conflict
+        raise ArgumentError, _("Option %{option} conflicts with existing option %{conflict}") %
+            { option: option, conflict: conflict }
+      end
+
+      actions.each do |action|
+        action = get_action(action)
+        conflict = action.get_option(name)
+        if conflict
+          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

data/lib/puppet/interface.rb

@@ -0,0 +1,239 @@
+require_relative '../puppet'
+require_relative '../puppet/util/autoload'
+require 'prettyprint'
+
+# @api public
+class Puppet::Interface
+  require_relative 'interface/documentation'
+  require_relative 'interface/face_collection'
+
+  require_relative 'interface/action'
+  require_relative 'interface/action_builder'
+  require_relative 'interface/action_manager'
+
+  require_relative 'interface/option'
+  require_relative 'interface/option_builder'
+  require_relative '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)
+      face = Puppet::Interface::FaceCollection[name, version]
+      unless face
+        # 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}"
+        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
+  private_class_method :__add_method
+end

data/lib/puppet/loaders.rb

@@ -0,0 +1,30 @@
+require_relative '../puppet/concurrent/synchronized'
+
+module Puppet
+  module Pops
+    require_relative '../puppet/pops/loaders'
+
+    module Loader
+      require_relative '../puppet/pops/loader/typed_name'
+      require_relative '../puppet/pops/loader/loader'
+      require_relative '../puppet/pops/loader/base_loader'
+      require_relative '../puppet/pops/loader/gem_support'
+      require_relative '../puppet/pops/loader/module_loaders'
+      require_relative '../puppet/pops/loader/dependency_loader'
+      require_relative '../puppet/pops/loader/static_loader'
+      require_relative '../puppet/pops/loader/runtime3_type_loader'
+      require_relative '../puppet/pops/loader/ruby_function_instantiator'
+      require_relative '../puppet/pops/loader/ruby_legacy_function_instantiator'
+      require_relative '../puppet/pops/loader/ruby_data_type_instantiator'
+      require_relative '../puppet/pops/loader/puppet_function_instantiator'
+      require_relative '../puppet/pops/loader/type_definition_instantiator'
+      require_relative '../puppet/pops/loader/puppet_resource_type_impl_instantiator'
+      require_relative '../puppet/pops/loader/loader_paths'
+      require_relative '../puppet/pops/loader/simple_environment_loader'
+      require_relative '../puppet/pops/loader/predefined_loader'
+      require_relative '../puppet/pops/loader/generic_plan_instantiator'
+      require_relative '../puppet/pops/loader/puppet_plan_instantiator'
+    end
+  end
+
+end

data/lib/puppet/metatype/manager.rb

@@ -0,0 +1,197 @@
+require_relative '../../puppet'
+require_relative '../../puppet/util/classgen'
+require_relative '../../puppet/node/environment'
+
+# This module defines methods dealing with Type management.
+# This module gets included into the Puppet::Type class, it's just split out here for clarity.
+# @api public
+#
+module Puppet::MetaType
+module Manager
+  include Puppet::Util::ClassGen
+
+  # An implementation specific method that removes all type instances during testing.
+  # @note Only use this method for testing purposes.
+  # @api private
+  #
+  def allclear
+    @types.each { |name, type|
+      type.clear
+    }
+  end
+
+  # Clears any types that were used but absent when types were last loaded.
+  # @note Used after each catalog compile when always_retry_plugins is false
+  # @api private
+  #
+  def clear_misses
+    unless @types.nil?
+      @types.delete_if {|_, v| v.nil? }
+    end
+  end
+
+  # Iterates over all already loaded Type subclasses.
+  # @yield [t] a block receiving each type
+  # @yieldparam t [Puppet::Type] each defined type
+  # @yieldreturn [Object] the last returned object is also returned from this method
+  # @return [Object] the last returned value from the block.
+  def eachtype
+    @types.each do |name, type|
+      # Only consider types that have names
+      #if ! type.parameters.empty? or ! type.validproperties.empty?
+        yield type
+      #end
+    end
+  end
+
+  # Loads all types.
+  # @note Should only be used for purposes such as generating documentation as this is potentially a very
+  #  expensive operation.
+  # @return [void]
+  #
+  def loadall
+    typeloader.loadall(Puppet.lookup(:current_environment))
+  end
+
+  # Defines a new type or redefines an existing type with the given name.
+  # A convenience method on the form `new<name>` where name is the name of the type is also created.
+  # (If this generated method happens to clash with an existing method, a warning is issued and the original
+  # method is kept).
+  #
+  # @param name [String] the name of the type to create or redefine.
+  # @param options [Hash] options passed on to {Puppet::Util::ClassGen#genclass} as the option `:attributes`.
+  # @option options [Puppet::Type]
+  #   Puppet::Type. This option is not passed on as an attribute to genclass.
+  # @yield [ ] a block evaluated in the context of the created class, thus allowing further detailing of
+  #   that class.
+  # @return [Class<inherits Puppet::Type>] the created subclass
+  # @see Puppet::Util::ClassGen.genclass
+  #
+  # @dsl type
+  # @api public
+  def newtype(name, options = {}, &block)
+    @manager_lock.synchronize do
+      # Handle backward compatibility
+      unless options.is_a?(Hash)
+        #TRANSLATORS 'Puppet::Type.newtype' should not be translated
+        Puppet.warning(_("Puppet::Type.newtype(%{name}) now expects a hash as the second argument, not %{argument}") %
+                       { name: name, argument: options.inspect})
+      end
+
+      # First make sure we don't have a method sitting around
+      name = name.intern
+      newmethod = "new#{name}"
+
+      # Used for method manipulation.
+      selfobj = singleton_class
+
+      if @types.include?(name)
+        if self.respond_to?(newmethod)
+          # Remove the old newmethod
+          selfobj.send(:remove_method,newmethod)
+        end
+      end
+
+      # Then create the class.
+
+      klass = genclass(
+        name,
+        :parent => Puppet::Type,
+        :overwrite => true,
+        :hash => @types,
+        :attributes => options,
+        &block
+      )
+
+      # Now define a "new<type>" method for convenience.
+      if self.respond_to? newmethod
+        # Refuse to overwrite existing methods like 'newparam' or 'newtype'.
+        #TRANSLATORS 'new%{method}' will become a method name, do not translate this string
+        Puppet.warning(_("'new%{method}' method already exists; skipping") % { method: name.to_s })
+      else
+        selfobj.send(:define_method, newmethod) do |*args|
+          klass.new(*args)
+        end
+      end
+
+      # If they've got all the necessary methods defined and they haven't
+      # already added the property, then do so now.
+      klass.ensurable if klass.ensurable? and ! klass.validproperty?(:ensure)
+
+      # Now set up autoload any providers that might exist for this type.
+
+      klass.providerloader = Puppet::Util::Autoload.new(klass, "puppet/provider/#{klass.name}")
+
+      # We have to load everything so that we can figure out the default provider.
+      klass.providerloader.loadall(Puppet.lookup(:current_environment))
+      klass.providify unless klass.providers.empty?
+
+      loc = block_given? ? block.source_location : nil
+      uri = loc.nil? ? nil : URI("#{Puppet::Util.path_to_uri(loc[0])}?line=#{loc[1]}")
+      Puppet::Pops::Loaders.register_runtime3_type(name, uri)
+
+      klass
+    end
+  end
+
+  # Removes an existing type.
+  # @note Only use this for testing.
+  # @api private
+  def rmtype(name)
+    # Then create the class.
+
+    rmclass(name, :hash => @types)
+
+    singleton_class.send(:remove_method, "new#{name}") if respond_to?("new#{name}")
+  end
+
+  # Returns a Type instance by name.
+  # This will load the type if not already defined.
+  # @param [String, Symbol] name of the wanted Type
+  # @return [Puppet::Type, nil] the type or nil if the type was not defined and could not be loaded
+  #
+  def type(name)
+    @manager_lock.synchronize do
+      # Avoid loading if name obviously is not a type name
+      if name.to_s.include?(':')
+        return nil
+      end
+
+      # We are overwhelmingly symbols here, which usually match, so it is worth
+      # having this special-case to return quickly.  Like, 25K symbols vs. 300
+      # strings in this method. --daniel 2012-07-17
+      return @types[name] if @types.include? name
+
+      # Try mangling the name, if it is a string.
+      if name.is_a? String
+        name = name.downcase.intern
+        return @types[name] if @types.include? name
+      end
+      # Try loading the type.
+      if typeloader.load(name, Puppet.lookup(:current_environment))
+        #TRANSLATORS 'puppet/type/%{name}' should not be translated
+        Puppet.warning(_("Loaded puppet/type/%{name} but no class was created") % { name: name }) unless @types.include? name
+      elsif !Puppet[:always_retry_plugins]
+        # PUP-5482 - Only look for a type once if plugin retry is disabled
+        @types[name] = nil
+      end
+
+      # ...and I guess that is that, eh.
+      return @types[name]
+    end
+  end
+
+  # Creates a loader for Puppet types.
+  # Defaults to an instance of {Puppet::Util::Autoload} if no other auto loader has been set.
+  # @return [Puppet::Util::Autoload] the loader to use.
+  # @api private
+  def typeloader
+    unless defined?(@typeloader)
+      @typeloader = Puppet::Util::Autoload.new(self, "puppet/type")
+    end
+
+    @typeloader
+  end
+end
+end
+