bolt 0.19.1 → 0.20.0

data/vendored/puppet/lib/puppet/parser/script_compiler.rb

@@ -1,118 +0,0 @@
-require 'puppet/loaders'
-require 'puppet/pops'
-
-# A Script "compiler" that does not support catalog operations
-#
-# The Script compiler is "one shot" - it does not support rechecking if underlying source has changed or
-# deal with possible errors in a cached environment.
-#
-class Puppet::Parser::ScriptCompiler
-  # Allows the ScriptCompiler to use the 3.x Scope class without being an actual "Compiler"
-  #
-  include Puppet::Parser::AbstractCompiler
-
-  # @api private
-  attr_reader :topscope
-
-  # @api private
-  attr_reader :qualified_variables
-
-  # Access to the configured loaders for 4x
-  # @return [Puppet::Pops::Loader::Loaders] the configured loaders
-  # @api private
-  attr_reader :loaders
-
-  # @api private
-  attr_reader :environment
-
-  # @api private
-  attr_reader :node_name
-
-  def with_context_overrides(description = '', &block)
-    Puppet.override( @context_overrides , description, &block)
-  end
-
-  # Evaluates the configured setup for a script + code in an environment with modules
-  #
-  def compile
-    Puppet[:strict_variables] = true
-    Puppet[:strict] = :error
-
-    # TRANSLATORS, "For running script" is not user facing
-    Puppet.override( @context_overrides , "For running script") do
-
-      #TRANSLATORS "main" is a function name and should not be translated
-      result = Puppet::Util::Profiler.profile(_("Script: Evaluated main"), [:script, :evaluate_main]) { evaluate_main }
-      if block_given?
-        yield self
-      else
-        result
-      end
-    end
-
-  rescue Puppet::ParseErrorWithIssue => detail
-    detail.node = node_name
-    Puppet.log_exception(detail)
-    raise
-  rescue => detail
-    message = "#{detail} on node #{node_name}"
-    Puppet.log_exception(detail, message)
-    raise Puppet::Error, message, detail.backtrace
-  end
-
-  # Constructs the overrides for the context
-  def context_overrides()
-    {
-      :current_environment => environment,
-      :global_scope => @topscope,             # 4x placeholder for new global scope
-      :loaders  => @loaders,                  # 4x loaders
-    }
-  end
-
-  # Create a script compiler for the given environment where errors are logged as coming
-  # from the given node_name
-  #
-  def initialize(environment, node_name)
-    @environment = environment
-    @node_name = node_name
-
-    # Create the initial scope, it is needed early
-    @topscope = Puppet::Parser::Scope.new(self)
-
-    # Initialize loaders and Pcore
-    @loaders = Puppet::Pops::Loaders.new(environment)
-
-    # Need to compute overrides here, and remember them, because we are about to
-    # Expensive entries in the context are bound lazily.
-    @context_overrides = context_overrides()
-
-    # Resolutions of fully qualified variable names
-    @qualified_variables = {}
-  end
-
-  # Having multiple named scopes hanging from top scope is not supported when scripting
-  # in the regular compiler this is used to create one named scope per class.
-  # When scripting, the "main class" is just a container of the top level code to evaluate
-  # and it is not evaluated as a class added to a catalog. Since classes are not supported
-  # there is no need to support the concept of "named scopes" as all variables are local
-  # or in the top scope itself (notably, the $settings:: namespace is initialized
-  # as just a set of variables in that namespace - there is no named scope for 'settings'
-  # when scripting.
-  # 
-  # Keeping this method here to get specific error as being unsure if there are functions/logic
-  # that will call this. The AbstractCompiler defines this method, but maybe it does not
-  # have to (TODO).
-  #
-  def newscope(parent, options = {})
-     raise _('having multiple named scopes is not supported when scripting')
-  end
-
-  private
-
-  # Find and evaluate the top level code.
-  def evaluate_main
-    @loaders.pre_load
-    program = @loaders.load_main_manifest
-    return program.nil? ? nil : Puppet::Pops::Parser::EvaluatingParser.singleton.evaluator.evaluate(program, @topscope)
-  end
-end

data/vendored/puppet/lib/puppet/parser/templatewrapper.rb

@@ -1,102 +0,0 @@
-require 'puppet/parser/files'
-require 'erb'
-require 'puppet/file_system'
-
-# A simple wrapper for templates, so they don't have full access to
-# the scope objects.
-#
-# @api private
-class Puppet::Parser::TemplateWrapper
-  include Puppet::Util
-  Puppet::Util.logmethods(self)
-
-  def initialize(scope)
-    @__scope__ = scope
-  end
-
-  # @return [String] The full path name of the template that is being executed
-  # @api public
-  def file
-    @__file__
-  end
-
-  # @return [Puppet::Parser::Scope] The scope in which the template is evaluated
-  # @api public
-  def scope
-    @__scope__
-  end
-
-  # Find which line in the template (if any) we were called from.
-  # @return [String] the line number
-  # @api private
-  def script_line
-    identifier = Regexp.escape(@__file__ || "(erb)")
-    (caller.find { |l| l =~ /#{identifier}:/ }||"")[/:(\d+):/,1]
-  end
-  private :script_line
-
-  # Should return true if a variable is defined, false if it is not
-  # @api public
-  def has_variable?(name)
-    scope.include?(name.to_s)
-  end
-
-  # @return [Array<String>] The list of defined classes
-  # @api public
-  def classes
-    scope.catalog.classes
-  end
-
-  # @return [Array<String>] The tags defined in the current scope
-  # @api public
-  def tags
-    scope.tags
-  end
-
-  # @return [Array<String>] All the defined tags
-  # @api public
-  def all_tags
-    scope.catalog.tags
-  end
-
-  # @api private
-  def file=(filename)
-    unless @__file__ = Puppet::Parser::Files.find_template(filename, scope.compiler.environment)
-      raise Puppet::ParseError, _("Could not find template '%{filename}'") % { filename: filename }
-    end
-  end
-
-  # @api private
-  def result(string = nil)
-    if string
-      template_source = "inline template"
-    else
-      string = Puppet::FileSystem.read_preserve_line_endings(@__file__)
-      template_source = @__file__
-    end
-
-    # Expose all the variables in our scope as instance variables of the
-    # current object, making it possible to access them without conflict
-    # to the regular methods.
-    escaped_template_source = template_source.gsub(/%/, '%%')
-    benchmark(:debug, _("Bound template variables for %{template_source} in %%{seconds} seconds") % { template_source: escaped_template_source }) do
-      scope.to_hash.each do |name, value|
-        realname = name.gsub(/[^\w]/, "_")
-        instance_variable_set("@#{realname}", value)
-      end
-    end
-
-    result = nil
-    benchmark(:debug, _("Interpolated template %{template_source} in %%{seconds} seconds") % { template_source: escaped_template_source }) do
-      template = ERB.new(string, 0, "-")
-      template.filename = @__file__
-      result = template.result(binding)
-    end
-
-    result
-  end
-
-  def to_s
-    "template[#{(@__file__ ? @__file__ : "inline")}]"
-  end
-end

data/vendored/puppet/lib/puppet/parser/type_loader.rb

@@ -1,149 +0,0 @@
-require 'find'
-require 'forwardable'
-require 'puppet/parser/parser_factory'
-
-class Puppet::Parser::TypeLoader
-  extend  Forwardable
-
-  class TypeLoaderError < StandardError; end
-
-  # Import manifest files that match a given file glob pattern.
-  #
-  # @param pattern [String] the file glob to apply when determining which files
-  #   to load
-  # @param dir [String] base directory to use when the file is not
-  #   found in a module
-  # @api private
-  def import(pattern, dir)
-    modname, files = Puppet::Parser::Files.find_manifests_in_modules(pattern, environment)
-    if files.empty?
-      abspat = File.expand_path(pattern, dir)
-      file_pattern = abspat + (File.extname(abspat).empty? ? '.pp' : '' )
-
-      files = Dir.glob(file_pattern).uniq.reject { |f| FileTest.directory?(f) }
-      modname = nil
-
-      if files.empty?
-        raise_no_files_found(pattern)
-      end
-    end
-
-    load_files(modname, files)
-  end
-
-  # Load all of the manifest files in all known modules.
-  # @api private
-  def import_all
-    # And then load all files from each module, but (relying on system
-    # behavior) only load files from the first module of a given name.  E.g.,
-    # given first/foo and second/foo, only files from first/foo will be loaded.
-    environment.modules.each do |mod|
-      load_files(mod.name, mod.all_manifests)
-    end
-  end
-
-  def_delegator :environment, :known_resource_types
-
-  def initialize(env)
-    self.environment = env
-  end
-
-  def environment
-    @environment
-  end
-
-  def environment=(env)
-    if env.is_a?(String) or env.is_a?(Symbol)
-      @environment = Puppet.lookup(:environments).get!(env)
-    else
-      @environment = env
-    end
-  end
-
-  # Try to load the object with the given fully qualified name.
-  def try_load_fqname(type, fqname)
-    return nil if fqname == "" # special-case main.
-    files_to_try_for(fqname).each do |filename|
-      begin
-        imported_types = import_from_modules(filename)
-        if result = imported_types.find { |t| t.type == type and t.name == fqname }
-          Puppet.debug {"Automatically imported #{fqname} from #{filename} into #{environment}"}
-          return result
-        end
-      rescue TypeLoaderError
-        # I'm not convinced we should just drop these errors, but this
-        # preserves existing behaviours.
-      end
-    end
-    # Nothing found.
-    return nil
-  end
-
-  def parse_file(file)
-    Puppet.debug("importing '#{file}' in environment #{environment}")
-    parser = Puppet::Parser::ParserFactory.parser
-    parser.file = file
-    return parser.parse
-  end
-
-  private
-
-  def import_from_modules(pattern)
-    modname, files = Puppet::Parser::Files.find_manifests_in_modules(pattern, environment)
-    if files.empty?
-      raise_no_files_found(pattern)
-    end
-
-    load_files(modname, files)
-  end
-
-  def raise_no_files_found(pattern)
-    raise TypeLoaderError, _("No file(s) found for import of '%{pattern}'") % { pattern: pattern }
-  end
-
-  def load_files(modname, files)
-    @loaded ||= {}
-    loaded_asts = []
-    files.reject { |file| @loaded[file] }.each do |file|
-    # The squelch_parse_errors use case is for parsing for the purpose of searching
-    # for information and it should not abort.
-    # There is currently one user in indirector/resourcetype/parser
-    #
-    if Puppet.lookup(:squelch_parse_errors) {|| false }
-      begin
-        loaded_asts << parse_file(file)
-      rescue => e
-        # Resume from errors so that all parseable files may
-        # still be parsed. Mark this file as loaded so that
-        # it would not be parsed next time (handle it as if
-        # it was successfully parsed).
-        Puppet.debug("Unable to parse '#{file}': #{e.message}")
-      end
-    else
-      loaded_asts << parse_file(file)
-    end
-
-    @loaded[file] = true
-    end
-
-    loaded_asts.collect do |ast|
-      known_resource_types.import_ast(ast, modname)
-    end.flatten
-  end
-
-  # Return a list of all file basenames that should be tried in order
-  # to load the object with the given fully qualified name.
-  def files_to_try_for(qualified_name)
-    qualified_name.split('::').inject([]) do |paths, name|
-      add_path_for_name(paths, name)
-    end
-  end
-
-  def add_path_for_name(paths, name)
-    if paths.empty?
-      [name]
-    else
-      paths.unshift(File.join(paths.first, name))
-    end
-  end
-end

data/vendored/puppet/lib/puppet/plugins.rb

@@ -1,9 +0,0 @@
-# The Puppet Plugins module defines extension points where plugins can be configured
-# to add or modify puppet's behavior. See the respective classes in this module for more
-# details.
-#
-# @api public
-# @since Puppet 4.0.0
-#
-module Puppet::Plugins
-end

data/vendored/puppet/lib/puppet/plugins/configuration.rb

@@ -1,25 +0,0 @@
-# Configures the Puppet Plugins, by registering extension points
-# and default implementations.
-#
-# See the respective configured services for more information.
-#
-# @api private
-#
-module Puppet::Plugins
-  module Configuration
-    require 'puppet/plugins/syntax_checkers'
-    require 'puppet/syntax_checkers/base64'
-    require 'puppet/syntax_checkers/json'
-
-    def self.load_plugins
-      # Register extensions
-      # -------------------
-      {
-        SyntaxCheckers::SYNTAX_CHECKERS_KEY => {
-          'json' => Puppet::SyntaxCheckers::Json.new,
-          'base64' => Puppet::SyntaxCheckers::Base64.new
-        }
-      }
-    end
-  end
-end

data/vendored/puppet/lib/puppet/plugins/syntax_checkers.rb

@@ -1,98 +0,0 @@
-module Puppet::Plugins
-module SyntaxCheckers
-
-  # The lookup **key** for the multibind containing syntax checkers used to syntax check embedded string in non
-  # puppet DSL syntax.
-  # @api public
-  SYNTAX_CHECKERS_KEY = :'puppet::syntaxcheckers'
-
-  # SyntaxChecker is a Puppet Extension Point for the purpose of extending Puppet with syntax checkers.
-  # The intended use is to create a class derived from this class and then register it with the Puppet context
-  #
-  # Creating the Extension Class
-  # ----------------------------
-  # As an example, a class for checking custom xml (aware of some custom schemes) may be authored in
-  # say a puppet module called 'exampleorg/xmldata'. The name of the class should start with `Puppetx::<user>::<module>`,
-  # e.g. 'Puppetx::Exampleorg::XmlData::XmlChecker" and
-  # be located in `lib/puppetx/exampleorg/xml_data/xml_checker.rb`. The Puppet Binder will auto-load this file when it
-  # has a binding to the class `Puppetx::Exampleorg::XmlData::XmlChecker'
-  # The Ruby Module `Puppetx` is created by Puppet, the remaining modules should be created by the loaded logic - e.g.:
-  #
-  # @example Defining an XmlChecker
-  #   module Puppetx::Exampleorg
-  #     module XmlData
-  #       class XmlChecker < Puppetx::Puppetlabs::SyntaxCheckers::SyntaxChecker
-  #         def check(text, syntax_identifier, acceptor, location_hash)
-  #            # do the checking
-  #         end
-  #       end
-  #     end
-  #   end
-  #
-  # Implementing the check method
-  # -----------------------------
-  # The implementation of the {#check} method should naturally perform syntax checking of the given text/string and
-  # produce found issues on the given `acceptor`. These can be warnings or errors. The method should return `false` if
-  # any warnings or errors were produced (it is up to the caller to check for error/warning conditions and report them
-  # to the user).
-  #
-  # Issues are reported by calling the given `acceptor`, which takes a severity (e.g. `:error`,
-  # or `:warning), an {Puppet::Pops::Issues::Issue} instance, and a {Puppet::Pops::Adapters::SourcePosAdapter}
-  # (which describes details about linenumber, position, and length of the problem area). Note that the
-  # `location_info` given to the check method holds information about the location of the string in its *container*
-  # (e.g. the source position of a Heredoc); this information can be used if more detailed information is not
-  # available, or combined if there are more details (relative to the start of the checked string).
-  #
-  # @example Reporting an issue
-  #    # create an issue with a symbolic name (that can serve as a reference to more details about the problem),
-  #    # make the name unique
-  #    issue = Puppet::Pops::Issues::issue(:EXAMPLEORG_XMLDATA_ILLEGAL_XML) { "syntax error found in xml text" }
-  #    source_pos = Puppet::Pops::Adapters::SourcePosAdapter.new()
-  #    source_pos.line = info[:line] # use this if there is no detail from the used parser
-  #    source_pos.pos = info[:pos]   # use this pos if there is no detail from used parser
-  #
-  #    # report it
-  #    acceptor.accept(Puppet::Pops::Validation::Diagnostic.new(:error, issue, info[:file], source_pos, {}))
-  #
-  # There is usually a cap on the number of errors/warnings that are presented to the user, this is handled by the
-  # reporting logic, but care should be taken to not generate too many as the issues are kept in memory until
-  # the checker returns. The acceptor may set a limit and simply ignore issues past a certain (high) number of reported
-  # issues (this number is typically higher than the cap on issues reported to the user).
-  #
-  # The `syntax_identifier`
-  # -----------------------
-  # The extension makes use of a syntax identifier written in mime-style. This identifier can be something simple
-  # as 'xml', or 'json', but can also consist of several segments joined with '+' where the most specific syntax variant
-  # is placed first. When searching for a syntax checker; say for JSON having some special traits, say 'userdata', the
-  # author of the text may indicate this as the text having the syntax "userdata+json" - when a checker is looked up it is
-  # first checked if there is a checker for "userdata+json", if none is found, a lookup is made for "json" (since the text
-  # must at least be valid json). The given identifier is passed to the checker (to allow the same checker to check for
-  # several dialects/specializations).
-  #
-  # Use in Puppet DSL
-  # -----------------
-  # The Puppet DSL Heredoc support makes use of the syntax checker extension. A user of a
-  # heredoc can specify the syntax in the heredoc tag, e.g.`@(END:userdata+json)`.
-  #
-  #
-  # @abstract
-  #
-  class SyntaxChecker
-    # Checks the text for syntax issues and reports them to the given acceptor.
-    # This implementation is abstract, it raises {NotImplementedError} since a subclass should have implemented the
-    # method.
-    #
-    # @param text [String] The text to check
-    # @param syntax_identifier [String] The syntax identifier in mime style (e.g. 'json', 'json-patch+json', 'xml', 'myapp+xml'
-    # @option location_info [String] :file The filename where the string originates
-    # @option location_info [Integer] :line The line number identifying the location where the string is being used/checked
-    # @option location_info [Integer] :position The position on the line identifying the location where the string is being used/checked
-    # @return [Boolean] Whether the checked string had issues (warnings and/or errors) or not.
-    # @api public
-    #
-    def check(text, syntax_identifier, acceptor, location_info)
-      raise NotImplementedError, "The class #{self.class.name} should have implemented the method check()"
-    end
-  end
-end
-end