puppet-retrospec 0.7.0 → 0.7.2

data/vendor/gems/puppet-3.7.3/lib/puppet/pops/loader/loader_paths.rb

@@ -0,0 +1,118 @@
+
+# LoaderPaths
+# ===
+# The central loader knowledge about paths, what they represent and how to instantiate from them.
+# Contains helpers (*smart paths*) to deal with lazy resolution of paths.
+#
+# TODO: Currently only supports loading of functions (3 kinds)
+#
+module Puppet::Pops::Loader::LoaderPaths
+  # Returns an array of SmartPath, each instantiated with a reference to the given loader (for root path resolution
+  # and existence checks). The smart paths in the array appear in precedence order. The returned array may be
+  # mutated.
+  #
+  def self.relative_paths_for_type(type, loader)
+    result =
+    case type
+    when :function
+        [FunctionPath4x.new(loader)]
+    else
+      # unknown types, simply produce an empty result; no paths to check, nothing to find... move along...
+      []
+    end
+    result
+  end
+
+#  # DO NOT REMOVE YET. needed later? when there is the need to decamel a classname
+#  def de_camel(fq_name)
+#    fq_name.to_s.gsub(/::/, '/').
+#    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+#    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+#    tr("-", "_").
+#    downcase
+#  end
+
+  class SmartPath
+    # Generic path, in the sense of "if there are any entities of this kind to load, where are they?"
+    attr_reader :generic_path
+
+    # Creates SmartPath for the given loader (loader knows how to check for existence etc.)
+    def initialize(loader)
+      @loader = loader
+    end
+
+    def generic_path()
+      return @generic_path unless @generic_path.nil?
+
+      root_path = @loader.path
+      @generic_path = (root_path.nil? ? relative_path : File.join(root_path, relative_path))
+    end
+
+    # Effective path is the generic path + the name part(s) + extension.
+    #
+    def effective_path(typed_name, start_index_in_name)
+      "#{File.join(generic_path, typed_name.name_parts)}#{extension}"
+    end
+
+    def relative_path()
+      raise NotImplementedError.new
+    end
+
+    def instantiator()
+      raise NotImplementedError.new
+    end
+  end
+
+  class RubySmartPath < SmartPath
+    def extension
+      ".rb"
+    end
+
+    # Duplication of extension information, but avoids one call
+    def effective_path(typed_name, start_index_in_name)
+      "#{File.join(generic_path, typed_name.name_parts)}.rb"
+    end
+  end
+
+  class FunctionPath4x < RubySmartPath
+    FUNCTION_PATH_4X = File.join('puppet', 'functions')
+
+    def relative_path
+      FUNCTION_PATH_4X
+    end
+
+    def instantiator()
+      Puppet::Pops::Loader::RubyFunctionInstantiator
+    end
+  end
+
+  # SmartPaths
+  # ===
+  # Holds effective SmartPath instances per type
+  #
+  class SmartPaths
+    def initialize(path_based_loader)
+      @loader = path_based_loader
+      @smart_paths = {}
+    end
+
+    # Ensures that the paths for the type have been probed and pruned to what is existing relative to
+    # the given root.
+    #
+    # @param type [Symbol] the entity type to load
+    # @return [Array<SmartPath>] array of effective paths for type (may be empty)
+    #
+    def effective_paths(type)
+      smart_paths = @smart_paths
+      loader = @loader
+      unless effective_paths = smart_paths[type]
+        # type not yet processed, does the various directories for the type exist ?
+        # Get the relative dirs for the type
+        paths_for_type = Puppet::Pops::Loader::LoaderPaths.relative_paths_for_type(type, loader)
+        # Check which directories exist in the loader's content/index
+        effective_paths = smart_paths[type] = paths_for_type.select { |sp| loader.meaningful_to_search?(sp) }
+      end
+      effective_paths
+    end
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/pops/loader/module_loaders.rb

@@ -0,0 +1,256 @@
+
+# =ModuleLoaders
+# A ModuleLoader loads items from a single module.
+# The ModuleLoaders (ruby) module contains various such loaders. There is currently one concrete
+# implementation, ModuleLoaders::FileBased that loads content from the file system.
+# Other implementations can be created - if they are based on name to path mapping where the path
+# is relative to a root path, they can derive the base behavior from the ModuleLoaders::AbstractPathBasedModuleLoader class.
+#
+# Examples of such extensions could be a zip/jar/compressed file base loader.
+#
+# Notably, a ModuleLoader does not configure itself - it is given the information it needs (the root, its name etc.)
+# Logic higher up in the loader hierarchy of things makes decisions based on the "shape of modules", and "available
+# modules" to determine which module loader to use for each individual module. (There could be differences in
+# internal layout etc.)
+#
+# A module loader is also not aware of the mapping of name to relative paths - this is performed by the
+# included module Puppet::Pops::Loader::PathBasedInstantatorConfig which knows about the map from type/name to
+# relative path, and the logic that can instantiate what is expected to be found in the content of that path.
+#
+# @api private
+#
+module Puppet::Pops::Loader::ModuleLoaders
+  def self.system_loader_from(parent_loader, loaders)
+    # Puppet system may be installed in a fixed location via RPM, installed as a Gem, via source etc.
+    # The only way to find this across the different ways puppet can be installed is
+    # to search up the path from this source file's __FILE__ location until it finds the base of
+    # puppet.
+    #
+    puppet_lib = File.join(File.dirname(__FILE__), '../../..')
+    Puppet::Pops::Loader::ModuleLoaders::FileBased.new(parent_loader,
+                                                       loaders,
+                                                       nil,
+                                                       puppet_lib,
+                                                       'puppet_system')
+  end
+
+  def self.module_loader_from(parent_loader, loaders, module_name, module_path)
+    Puppet::Pops::Loader::ModuleLoaders::FileBased.new(parent_loader,
+                                                       loaders,
+                                                       module_name,
+                                                       File.join(module_path, 'lib'),
+                                                       module_name)
+  end
+
+  class AbstractPathBasedModuleLoader < Puppet::Pops::Loader::BaseLoader
+
+    # The name of the module, or nil, if this is a global "component"
+    attr_reader :module_name
+
+    # The path to the location of the module/component - semantics determined by subclass
+    attr_reader :path
+
+    # A map of type to smart-paths that help with minimizing the number of paths to scan
+    attr_reader :smart_paths
+
+    # A Module Loader has a private loader, it is lazily obtained on request to provide the visibility
+    # for entities contained in the module. Since a ModuleLoader also represents an environment and it is
+    # created a different way, this loader can be set explicitly by the loaders bootstrap logic.
+    #
+    # @api private
+    attr_accessor :private_loader
+
+    # Initialize a kind of ModuleLoader for one module
+    # @param parent_loader [Puppet::Pops::Loader] loader with higher priority
+    # @param module_name [String] the name of the module (non qualified name), may be nil for a global "component"
+    # @param path [String] the path to the root of the module (semantics defined by subclass)
+    # @param loader_name [String] a name that is used for human identification (useful when module_name is nil)
+    #
+    def initialize(parent_loader, loaders, module_name, path, loader_name)
+      super parent_loader, loader_name
+
+      @module_name = module_name
+      @path = path
+      @smart_paths = Puppet::Pops::Loader::LoaderPaths::SmartPaths.new(self)
+      @loaders = loaders
+    end
+
+    # Finds typed/named entity in this module
+    # @param typed_name [Puppet::Pops::Loader::TypedName] the type/name to find
+    # @return [Puppet::Pops::Loader::Loader::NamedEntry, nil found/created entry, or nil if not found
+    #
+    def find(typed_name)
+      # Assume it is a global name, and that all parts of the name should be used when looking up
+      name_part_index = 0
+      name_parts = typed_name.name_parts
+
+      # Certain types and names can be disqualified up front
+      if name_parts.size > 1
+        # The name is in a name space.
+
+        # Then entity cannot possible be in this module unless the name starts with the module name.
+        # Note: If "module" represents a "global component", the module_name is nil and cannot match which is
+        # ok since such a "module" cannot have namespaced content).
+        #
+        return nil unless name_parts[0] == module_name
+
+        # Skip the first part of the name when computing the path since the path already contains the name of the
+        # module
+        name_part_index = 1
+      else
+        # The name is in the global name space.
+
+        # The only globally name-spaced elements that may be loaded from modules are functions and resource types
+        case typed_name.type
+        when :function
+        when :resource_type
+        else
+          # anything else cannot possibly be in this module
+          # TODO: should not be allowed anyway... may have to revisit this decision
+          return nil
+        end
+      end
+
+      # Get the paths that actually exist in this module (they are lazily processed once and cached).
+      # The result is an array (that may be empty).
+      # Find the file to instantiate, and instantiate the entity if file is found
+      origin = nil
+      if (smart_path = smart_paths.effective_paths(typed_name.type).find do |sp|
+          origin = sp.effective_path(typed_name, name_part_index)
+          existing_path(origin)
+        end)
+        value = smart_path.instantiator.create(self, typed_name, origin, get_contents(origin))
+        # cache the entry and return it
+        set_entry(typed_name, value, origin)
+      else
+        nil
+      end
+    end
+
+    # Abstract method that subclasses override that checks if it is meaningful to search using a generic smart path.
+    # This optimization is performed to not be tricked into searching an empty directory over and over again.
+    # The implementation may perform a deep search for file content other than directories and cache this in
+    # and index. It is guaranteed that a call to meaningful_to_search? takes place before checking any other
+    # path with relative_path_exists?.
+    #
+    # This optimization exists because many modules have been created from a template and they have
+    # empty directories for functions, types, etc. (It is also the place to create a cached index of the content).
+    #
+    # @param smart_path [String] a path relative to the module's root
+    # @return [Boolean] true if there is content in the directory appointed by the relative path
+    #
+    def meaningful_to_search?(smart_path)
+      raise NotImplementedError.new
+    end
+
+    # Abstract method that subclasses override to answer if the given relative path exists, and if so returns that path
+    #
+    # @param resolved_path [String] a path resolved by a smart path against the loader's root (if it has one)
+    # @return [Boolean] true if the file exists
+    #
+    def existing_path(resolved_path)
+      raise NotImplementedError.new
+    end
+
+    # Abstract method that subclasses override to produce the content of the effective path.
+    # It should either succeed and return a String or fail with an exception.
+    #
+    # @param effective_path [String] a path as resolved by a smart path
+    # @return [String] the content of the file
+    #
+    def get_contents(effective_path)
+      raise NotImplementedError.new
+    end
+
+    # Abstract method that subclasses override to produce a source reference String used to identify the
+    # system resource (resource in the URI sense).
+    #
+    # @param relative_path [String] a path relative to the module's root
+    # @return [String] a reference to the source file (in file system, zip file, or elsewhere).
+    #
+    def get_source_ref(relative_path)
+      raise NotImplementedError.new
+    end
+
+    # Produces the private loader for the module. If this module is not already resolved, this will trigger resolution
+    #
+    def private_loader
+      @private_loader ||= @loaders.private_loader_for_module(module_name)
+    end
+  end
+
+  # @api private
+  #
+  class FileBased < AbstractPathBasedModuleLoader
+
+    attr_reader :smart_paths
+    attr_reader :path_index
+
+    # Create a kind of ModuleLoader for one module (Puppet Module, or module like)
+    #
+    # @param parent_loader [Puppet::Pops::Loader::Loader] typically the loader for the environment or root
+    # @param module_name [String] the name of the module (non qualified name), may be nil for "modules" only containing globals
+    # @param path [String] the path to the root of the module (semantics defined by subclass)
+    # @param loader_name [String] a name that identifies the loader
+    #
+    def initialize(parent_loader, loaders, module_name, path, loader_name)
+      super
+      @path_index = Set.new()
+    end
+
+    def existing_path(effective_path)
+      # Optimized, checks index instead of visiting file system
+      @path_index.include?(effective_path) ? effective_path : nil
+    end
+
+    def meaningful_to_search?(smart_path)
+      ! add_to_index(smart_path).empty?
+    end
+
+    def to_s()
+      "(ModuleLoader::FileBased '#{loader_name()}' '#{module_name()}')"
+    end
+
+    def add_to_index(smart_path)
+      found = Dir.glob(File.join(smart_path.generic_path, '**', "*#{smart_path.extension}"))
+      @path_index.merge(found)
+      found
+    end
+
+    def get_contents(effective_path)
+      Puppet::FileSystem.read(effective_path)
+    end
+  end
+
+  # Loads from a gem specified as a URI, gem://gemname/optional/path/in/gem, or just a String gemname.
+  # The source reference (shown in errors etc.) is the expanded path of the gem as this is believed to be more
+  # helpful - given the location it should be quite obvious which gem it is, without the location, the user would
+  # need to go on a hunt for where the file actually is located.
+  #
+  # TODO: How does this get instantiated? Does the gemname refelect the name of the module (the namespace)
+  #   or is that specified a different way? Can a gem be the container of multiple modules?
+  #
+  # @api private
+  #
+  class GemBased < FileBased
+    include Puppet::Pops::Loader::GemSupport
+
+    attr_reader :gem_ref
+
+    # Create a kind of ModuleLoader for one module
+    # The parameters are:
+    # * parent_loader - typically the loader for the root
+    # * module_name - the name of the module (non qualified name)
+    # * gem_ref - [URI, String] gem reference to the root of the module (URI, gem://gemname/optional/path/in/gem), or
+    #     just the gem's name as a String.
+    #
+    def initialize(parent_loader, loaders, module_name, gem_ref, loader_name)
+      @gem_ref = gem_ref
+      super parent_loader, loaders, module_name, gem_dir(gem_ref), loader_name
+    end
+
+    def to_s()
+      "(ModuleLoader::GemBased '#{loader_name()}' '#{@gem_ref}' [#{module_name()}])"
+    end
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/pops/loader/null_loader.rb

@@ -0,0 +1,44 @@
+# The null loader is empty and delegates everything to its parent if it has one.
+#
+class Puppet::Pops::Loader::NullLoader < Puppet::Pops::Loader::Loader
+  attr_reader :loader_name
+
+  # Construct a NullLoader, optionally with a parent loader
+  #
+  def initialize(parent_loader=nil, loader_name = "null-loader")
+    @loader_name = loader_name
+    @parent = parent_loader
+  end
+
+  # Has parent if one was set when constructed
+  def parent
+    @parent
+  end
+
+  def load_typed(typed_name)
+    if @parent.nil?
+      nil
+    else
+      @parent.load_typed(typed_name)
+    end
+  end
+
+  # Has no entries on its own - always nil
+  def get_entry(typed_name)
+    nil
+  end
+
+  # Finds nothing, there are no entries
+  def find(name)
+    nil
+  end
+
+  # Cannot store anything
+  def set_entry(typed_name, value, origin = nil)
+    nil
+  end
+
+  def to_s()
+    "(NullLoader '#{loader_name}')"
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/pops/loader/ruby_function_instantiator.rb

@@ -0,0 +1,34 @@
+# The RubyFunctionInstantiator instantiates a Puppet::Functions::Function given the ruby source
+# that calls Puppet::Functions.create_function.
+#
+class Puppet::Pops::Loader::RubyFunctionInstantiator
+  # Produces an instance of the Function class with the given typed_name, or fails with an error if the
+  # given ruby source does not produce this instance when evaluated.
+  #
+  # @param loader [Puppet::Pops::Loader::Loader] The loader the function is associated with
+  # @param typed_name [Puppet::Pops::Loader::TypedName] the type / name of the function to load
+  # @param source_ref [URI, String] a reference to the source / origin of the ruby code to evaluate
+  # @param ruby_code_string [String] ruby code in a string
+  #
+  # @return [Puppet::Pops::Functions.Function] - an instantiated function with global scope closure associated with the given loader
+  #
+  def self.create(loader, typed_name, source_ref, ruby_code_string)
+    unless ruby_code_string.is_a?(String) && ruby_code_string =~ /Puppet\:\:Functions\.create_function/
+      raise ArgumentError, "The code loaded from #{source_ref} does not seem to be a Puppet 4x API function - no create_function call."
+    end
+    created = eval(ruby_code_string, nil, source_ref, 1)
+    unless created.is_a?(Class)
+      raise ArgumentError, "The code loaded from #{source_ref} did not produce a Function class when evaluated. Got '#{created.class}'"
+    end
+    unless created.name.to_s == typed_name.name()
+      raise ArgumentError, "The code loaded from #{source_ref} produced mis-matched name, expected '#{typed_name.name}', got #{created.name}"
+    end
+    # create the function instance - it needs closure (scope), and loader (i.e. where it should start searching for things
+    # when calling functions etc.
+    # It should be bound to global scope
+
+    # TODO: Cheating wrt. scope - assuming it is found in the context
+    closure_scope = Puppet.lookup(:global_scope) { {} }
+    created.new(closure_scope, loader.private_loader)
+  end
+end