puppet-retrospec 0.7.0 → 0.7.2

data/vendor/gems/puppet-3.7.3/lib/puppet/loaders.rb

@@ -0,0 +1,19 @@
+module Puppet
+  module Pops
+    require 'puppet/pops/loaders'
+
+    module Loader
+      require 'puppet/pops/loader/loader'
+      require 'puppet/pops/loader/base_loader'
+      require 'puppet/pops/loader/gem_support'
+      require 'puppet/pops/loader/module_loaders'
+      require 'puppet/pops/loader/dependency_loader'
+      require 'puppet/pops/loader/null_loader'
+      require 'puppet/pops/loader/static_loader'
+      require 'puppet/pops/loader/ruby_function_instantiator'
+      require 'puppet/pops/loader/loader_paths'
+      require 'puppet/pops/loader/simple_environment_loader'
+    end
+  end
+
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/metatype/manager.rb

@@ -0,0 +1,184 @@
+require 'puppet'
+require 'puppet/util/classgen'
+require '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
+
+  # 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
+  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)
+    # 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}"
+    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 options.include?(:parent) 
+      Puppet.deprecation_warning "option :parent is deprecated. It has no effect"
+      options.delete(:parent)
+    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'.
+      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
+
+  # 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)
+    # Avoid loading if name obviously is not a type name
+    if name.to_s.include?(':')
+      return nil
+    end
+
+    @types ||= {}
+
+    # 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[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.lookup(:current_environment))
+      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
+
+  # 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", :wrap => false)
+    end
+
+    @typeloader
+  end
+end
+end
+

data/vendor/gems/puppet-3.7.3/lib/puppet/module.rb

@@ -0,0 +1,339 @@
+require 'puppet/util/logging'
+require 'semver'
+require 'json'
+
+# Support for modules
+class Puppet::Module
+  class Error < Puppet::Error; end
+  class MissingModule < Error; end
+  class IncompatibleModule < Error; end
+  class UnsupportedPlatform < Error; end
+  class IncompatiblePlatform < Error; end
+  class MissingMetadata < Error; end
+  class InvalidName < Error; end
+  class InvalidFilePattern < Error; end
+
+  include Puppet::Util::Logging
+
+  FILETYPES = {
+    "manifests" => "manifests",
+    "files" => "files",
+    "templates" => "templates",
+    "plugins" => "lib",
+    "pluginfacts" => "facts.d",
+  }
+
+  # Find and return the +module+ that +path+ belongs to. If +path+ is
+  # absolute, or if there is no module whose name is the first component
+  # of +path+, return +nil+
+  def self.find(modname, environment = nil)
+    return nil unless modname
+    # Unless a specific environment is given, use the current environment
+    env = environment ? Puppet.lookup(:environments).get!(environment) : Puppet.lookup(:current_environment)
+    env.module(modname)
+  end
+
+  attr_reader :name, :environment, :path, :metadata
+  attr_writer :environment
+
+  attr_accessor :dependencies, :forge_name
+  attr_accessor :source, :author, :version, :license, :puppetversion, :summary, :description, :project_page
+
+  def initialize(name, path, environment)
+    @name = name
+    @path = path
+    @environment = environment
+
+    assert_validity
+
+    load_metadata if has_metadata?
+
+    validate_puppet_version
+
+    @absolute_path_to_manifests = Puppet::FileSystem::PathPattern.absolute(manifests)
+  end
+
+  def has_metadata?
+    return false unless metadata_file
+
+    return false unless Puppet::FileSystem.exist?(metadata_file)
+
+    begin
+      metadata =  JSON.parse(File.read(metadata_file))
+    rescue JSON::JSONError => e
+      Puppet.debug("#{name} has an invalid and unparsable metadata.json file.  The parse error: #{e.message}")
+      return false
+    end
+
+    return metadata.is_a?(Hash) && !metadata.keys.empty?
+  end
+
+  FILETYPES.each do |type, location|
+    # A boolean method to let external callers determine if
+    # we have files of a given type.
+    define_method(type +'?') do
+      type_subpath = subpath(location)
+      unless Puppet::FileSystem.exist?(type_subpath)
+        Puppet.debug("No #{type} found in subpath '#{type_subpath}' " +
+                         "(file / directory does not exist)")
+        return false
+      end
+
+      return true
+    end
+
+    # A method for returning a given file of a given type.
+    # e.g., file = mod.manifest("my/manifest.pp")
+    #
+    # If the file name is nil, then the base directory for the
+    # file type is passed; this is used for fileserving.
+    define_method(type.sub(/s$/, '')) do |file|
+      # If 'file' is nil then they're asking for the base path.
+      # This is used for things like fileserving.
+      if file
+        full_path = File.join(subpath(location), file)
+      else
+        full_path = subpath(location)
+      end
+
+      return nil unless Puppet::FileSystem.exist?(full_path)
+      return full_path
+    end
+
+    # Return the base directory for the given type
+    define_method(type) do
+      subpath(location)
+    end
+  end
+
+  def license_file
+    return @license_file if defined?(@license_file)
+
+    return @license_file = nil unless path
+    @license_file = File.join(path, "License")
+  end
+
+  def load_metadata
+    @metadata = data = JSON.parse(File.read(metadata_file))
+    @forge_name = data['name'].gsub('-', '/') if data['name']
+
+    [:source, :author, :version, :license, :puppetversion, :dependencies].each do |attr|
+      unless value = data[attr.to_s]
+        unless attr == :puppetversion
+          raise MissingMetadata, "No #{attr} module metadata provided for #{self.name}"
+        end
+      end
+
+      # NOTICE: The fallback to `versionRequirement` is something we'd like to
+      # not have to support, but we have a reasonable number of releases that
+      # don't use `version_requirement`. When we can deprecate this, we should.
+      if attr == :dependencies
+        value.tap do |dependencies|
+          dependencies.each do |dep|
+            dep['version_requirement'] ||= dep['versionRequirement'] || '>= 0.0.0'
+          end
+        end
+      end
+
+      send(attr.to_s + "=", value)
+    end
+  end
+
+  # Return the list of manifests matching the given glob pattern,
+  # defaulting to 'init.{pp,rb}' for empty modules.
+  def match_manifests(rest)
+    if rest
+      wanted_manifests = wanted_manifests_from(rest)
+      searched_manifests = wanted_manifests.glob.reject { |f| FileTest.directory?(f) }
+    else
+      searched_manifests = []
+    end
+
+    # (#4220) Always ensure init.pp in case class is defined there.
+    init_manifests = [manifest("init.pp"), manifest("init.rb")].compact
+    init_manifests + searched_manifests
+  end
+
+  def all_manifests
+    return [] unless Puppet::FileSystem.exist?(manifests)
+
+    Dir.glob(File.join(manifests, '**', '*.{rb,pp}'))
+  end
+
+  def metadata_file
+    return @metadata_file if defined?(@metadata_file)
+
+    return @metadata_file = nil unless path
+    @metadata_file = File.join(path, "metadata.json")
+  end
+
+  def modulepath
+    File.dirname(path) if path
+  end
+
+  # Find all plugin directories.  This is used by the Plugins fileserving mount.
+  def plugin_directory
+    subpath("lib")
+  end
+
+  def plugin_fact_directory
+    subpath("facts.d")
+  end
+
+  def has_external_facts?
+    File.directory?(plugin_fact_directory)
+  end
+
+  def supports(name, version = nil)
+    @supports ||= []
+    @supports << [name, version]
+  end
+
+  def to_s
+    result = "Module #{name}"
+    result += "(#{path})" if path
+    result
+  end
+
+  def dependencies_as_modules
+    dependent_modules = []
+    dependencies and dependencies.each do |dep|
+      author, dep_name = dep["name"].split('/')
+      found_module = environment.module(dep_name)
+      dependent_modules << found_module if found_module
+    end
+
+    dependent_modules
+  end
+
+  def required_by
+    environment.module_requirements[self.forge_name] || {}
+  end
+
+  def has_local_changes?
+    Puppet.deprecation_warning("This method is being removed.")
+    require 'puppet/module_tool/applications'
+    changes = Puppet::ModuleTool::Applications::Checksummer.run(path)
+    !changes.empty?
+  end
+
+  def local_changes
+    Puppet.deprecation_warning("This method is being removed.")
+    require 'puppet/module_tool/applications'
+    Puppet::ModuleTool::Applications::Checksummer.run(path)
+  end
+
+  # Identify and mark unmet dependencies.  A dependency will be marked unmet
+  # for the following reasons:
+  #
+  #   * not installed and is thus considered missing
+  #   * installed and does not meet the version requirements for this module
+  #   * installed and doesn't use semantic versioning
+  #
+  # Returns a list of hashes representing the details of an unmet dependency.
+  #
+  # Example:
+  #
+  #   [
+  #     {
+  #       :reason => :missing,
+  #       :name   => 'puppetlabs-mysql',
+  #       :version_constraint => 'v0.0.1',
+  #       :mod_details => {
+  #         :installed_version => '0.0.1'
+  #       }
+  #       :parent => {
+  #         :name    => 'puppetlabs-bacula',
+  #         :version => 'v1.0.0'
+  #       }
+  #     }
+  #   ]
+  #
+  def unmet_dependencies
+    unmet_dependencies = []
+    return unmet_dependencies unless dependencies
+
+    dependencies.each do |dependency|
+      forge_name = dependency['name']
+      version_string = dependency['version_requirement'] || '>= 0.0.0'
+
+      dep_mod = begin
+        environment.module_by_forge_name(forge_name)
+      rescue
+        nil
+      end
+
+      error_details = {
+        :name => forge_name,
+        :version_constraint => version_string.gsub(/^(?=\d)/, "v"),
+        :parent => {
+          :name => self.forge_name,
+          :version => self.version.gsub(/^(?=\d)/, "v")
+        },
+        :mod_details => {
+          :installed_version => dep_mod.nil? ? nil : dep_mod.version
+        }
+      }
+
+      unless dep_mod
+        error_details[:reason] = :missing
+        unmet_dependencies << error_details
+        next
+      end
+
+      if version_string
+        begin
+          required_version_semver_range = SemVer[version_string]
+          actual_version_semver = SemVer.new(dep_mod.version)
+        rescue ArgumentError
+          error_details[:reason] = :non_semantic_version
+          unmet_dependencies << error_details
+          next
+        end
+
+        unless required_version_semver_range.include? actual_version_semver
+          error_details[:reason] = :version_mismatch
+          unmet_dependencies << error_details
+          next
+        end
+      end
+    end
+
+    unmet_dependencies
+  end
+
+  def validate_puppet_version
+    return unless puppetversion and puppetversion != Puppet.version
+    raise IncompatibleModule, "Module #{self.name} is only compatible with Puppet version #{puppetversion}, not #{Puppet.version}"
+  end
+
+  private
+
+  def wanted_manifests_from(pattern)
+    begin
+      extended = File.extname(pattern).empty? ? "#{pattern}.{pp,rb}" : pattern
+      relative_pattern = Puppet::FileSystem::PathPattern.relative(extended)
+    rescue Puppet::FileSystem::PathPattern::InvalidPattern => error
+      raise Puppet::Module::InvalidFilePattern.new(
+        "The pattern \"#{pattern}\" to find manifests in the module \"#{name}\" " +
+        "is invalid and potentially unsafe.", error)
+    end
+
+    relative_pattern.prefix_with(@absolute_path_to_manifests)
+  end
+
+  def subpath(type)
+    File.join(path, type)
+  end
+
+  def assert_validity
+    raise InvalidName, "Invalid module name #{name}; module names must be alphanumeric (plus '-'), not '#{name}'" unless name =~ /^[-\w]+$/
+  end
+
+  def ==(other)
+    self.name == other.name &&
+    self.version == other.version &&
+    self.path == other.path &&
+    self.environment == other.environment
+  end
+end