# module Puppet::MetaType::Manager

### Public Instance Methods

allclear() click to toggle source

An implementation specific method that removes all type instances during testing. @note Only use this method for testing purposes. @api private

    # File lib/puppet/metatype/manager.rb, line 17
    def allclear
      @types.each { |name, type|
        type.clear
      }
    end

eachtype() { |type| ... } click to toggle source

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.

    # File lib/puppet/metatype/manager.rb, line 28
    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

loadall() click to toggle source

Loads all types.

@note Should only be used for purposes such as generating documentation as this is potentially a very

    expensive operation.

@return [void]

    # File lib/puppet/metatype/manager.rb, line 42
    def loadall
      typeloader.loadall
    end

newtype(name, options = {}, &block) click to toggle source

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` after

    first having removed any present `:parent` option.

@option options [Puppet::Type] :parent the parent (super type) of this type. If nil, the default is

    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

    # File lib/puppet/metatype/manager.rb, line 63
    def newtype(name, options = {}, &block)
      # Handle backward compatibility
      unless options.is_a?(Hash)
        Puppet.warning "Puppet::Type.newtype(#{name}) now expects a hash as the second argument, not #{options.inspect}"
        options = {:parent => options}
      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

      @types ||= {}

      if @types.include?(name)
        if self.respond_to?(newmethod)
          # Remove the old newmethod
          selfobj.send(:remove_method,newmethod)
        end
      end

      options = symbolize_options(options)

      if parent = options[:parent]
        options.delete(:parent)
      end

      # Then create the class.

      klass = genclass(
        name,
        :parent => (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'.
        Puppet.warning "'new#{name.to_s}' method already exists; skipping"
      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.to_s}")

      # We have to load everything so that we can figure out the default provider.
      klass.providerloader.loadall
      klass.providify unless klass.providers.empty?

      klass
    end

rmtype(name) click to toggle source

Removes an existing type. @note Only use this for testing. @api private

    # File lib/puppet/metatype/manager.rb, line 131
    def rmtype(name)
      # Then create the class.

      klass = rmclass(name, :hash => @types)

      singleton_class.send(:remove_method, "new#{name}") if respond_to?("new#{name}")
    end

type(name) click to toggle source

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

    # File lib/puppet/metatype/manager.rb, line 144
    def type(name)
      @types ||= {}

      # We are overwhelmingly symbols here, which usually match, so it is worth
      # having this special-case to return quickly.  Like, 25K to 300 symbols to
      # strings in this method. --daniel 2012-07-17
      return @types[name] if @types[name]

      # Try mangling the name, if it is a string.
      if name.is_a? String
        name = name.downcase.intern
        return @types[name] if @types[name]
      end

      # Try loading the type.
      if typeloader.load(name, Puppet::Node::Environment.current)
        Puppet.warning "Loaded puppet/type/#{name} but no class was created" unless @types.include? name
      end

      # ...and I guess that is that, eh.
      return @types[name]
    end

typeloader() click to toggle source

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

    # File lib/puppet/metatype/manager.rb, line 171
    def typeloader
      unless defined?(@typeloader)
        @typeloader = Puppet::Util::Autoload.new(self, "puppet/type", :wrap => false)
      end

      @typeloader
    end