RubyGems - bolt - Versions diffs - 0.24.0 → 0.25.0 - Mend

bolt 0.24.0 → 0.25.0

Potentially problematic release.

This version of bolt might be problematic. Click here for more details.

Files changed (1155) hide show

data/vendored/puppet/lib/puppet/face/catalog/select.rb DELETED

@@ -1,49 +0,0 @@
-# Select and show a list of resources of a given type.
-Puppet::Face.define(:catalog, '0.0.1') do
-  action :select do
-    summary _("Retrieve a catalog and filter it for resources of a given type.")
-    arguments _("<host> <resource_type>")
-    returns _(<<-'EOT')
-      A list of resource references ("Type[title]"). When used from the API,
-      returns an array of Puppet::Resource objects excised from a catalog.
-    EOT
-    description <<-'EOT'
-      Retrieves a catalog for the specified host, then searches it for all
-      resources of the requested type.
-    EOT
-    notes <<-'NOTES'
-      By default, this action will retrieve a catalog from Puppet's compiler
-      subsystem; you must call the action with `--terminus rest` if you wish
-      to retrieve a catalog from the puppet master.
-      FORMATTING ISSUES: This action cannot currently render useful yaml;
-      instead, it returns an entire catalog. Use json instead.
-    NOTES
-    examples <<-'EOT'
-      Ask the puppet master for a list of managed file resources for a node:
-      $ puppet catalog select --terminus rest somenode.magpie.lan file
-    EOT
-    when_invoked do |host, type, options|
-      # REVISIT: Eventually, type should have a default value that triggers
-      # the non-specific behaviour.  For now, though, this will do.
-      # --daniel 2011-05-03
-      catalog = Puppet::Resource::Catalog.indirection.find(host)
-      if type == '*'
-        catalog.resources
-      else
-        type = type.downcase
-        catalog.resources.reject { |res| res.type.downcase != type }
-      end
-    end
-    when_rendering :console do |value|
-      if value.nil? then
-        _("no matching resources found")
-      else
-        value.map {|x| x.to_s }.join("\n")
-      end
-    end
-  end
-end

data/vendored/puppet/lib/puppet/face/config.rb DELETED

@@ -1,265 +0,0 @@
-require 'puppet/face'
-require 'puppet/settings/ini_file'
-Puppet::Face.define(:config, '0.0.1') do
-  extend Puppet::Util::Colors
-  copyright "Puppet Inc.", 2011
-  license   _("Apache 2 license; see COPYING")
-  summary _("Interact with Puppet's settings.")
-  description "This subcommand can inspect and modify settings from Puppet's
-    'puppet.conf' configuration file. For documentation about individual settings,
-    see https://puppet.com/docs/puppet/latest/configuration.html."
-  DEFAULT_SECTION_MARKER = Object.new
-  DEFAULT_SECTION = "main"
-  option "--section " + _("SECTION_NAME") do
-    default_to { DEFAULT_SECTION_MARKER } #Sentinel object for default detection during commands
-    summary _("The section of the configuration file to interact with.")
-    description <<-EOT
-      The section of the puppet.conf configuration file to interact with.
-      The three most commonly used sections are 'main', 'master', and 'agent'.
-      'Main' is the default, and is used by all Puppet applications. Other
-      sections can override 'main' values for specific applications --- the
-      'master' section affects puppet master and puppet cert, and the 'agent'
-      section affects puppet agent.
-      Less commonly used is the 'user' section, which affects puppet apply. Any
-      other section will be treated as the name of a legacy environment
-      (a deprecated feature), and can only include the 'manifest' and
-      'modulepath' settings.
-    EOT
-  end
-  action(:print) do
-    summary _("Examine Puppet's current settings.")
-    arguments _("(all | <setting> [<setting> ...]")
-    description <<-'EOT'
-      Prints the value of a single setting or a list of settings.
-      This action is a replacement interface to the information available with
-      `puppet <subcommand> --configprint`.
-    EOT
-    notes <<-'EOT'
-      By default, this action reads the general configuration in the 'main'
-      section. Use the '--section' and '--environment' flags to examine other
-      configuration domains.
-    EOT
-    examples <<-'EOT'
-      Get puppet's runfile directory:
-      $ puppet config print rundir
-      Get a list of important directories from the master's config:
-      $ puppet config print all --section master | grep -E "(path|dir)"
-    EOT
-    when_invoked do |*args|
-      options = args.pop
-      @default_section = false
-      if options[:section] == DEFAULT_SECTION_MARKER
-        options[:section] = DEFAULT_SECTION
-        @default_section = true
-      end
-      render_all_settings = args.empty? || args == ['all']
-      args = Puppet.settings.to_a.collect(&:first) if render_all_settings
-      values_from_the_selected_section =
-        Puppet.settings.values(nil, options[:section].to_sym)
-      loader_settings = {
-        :environmentpath => values_from_the_selected_section.interpolate(:environmentpath),
-        :basemodulepath => values_from_the_selected_section.interpolate(:basemodulepath),
-      }
-      to_be_rendered = nil
-      Puppet.override(Puppet.base_context(loader_settings),
-                     _("New environment loaders generated from the requested section.")) do
-        # And now we can lookup values that include those from environments configured from
-        # the requested section
-        values = Puppet.settings.values(Puppet[:environment].to_sym, options[:section].to_sym)
-        if Puppet::Util::Log.sendlevel?(:info)
-          warn_default_section(options[:section]) if @default_section
-          report_section_and_environment(options[:section], Puppet.settings[:environment])
-        end
-        to_be_rendered = {}
-        args.sort.each do |setting_name|
-          to_be_rendered[setting_name] = values.print(setting_name.to_sym)
-        end
-      end
-      # convert symbols to strings before formatting output
-      if render_all_settings
-        to_be_rendered = stringifyhash(to_be_rendered)
-      end
-      to_be_rendered
-    end
-    when_rendering :console do |to_be_rendered|
-      output = ''
-      if to_be_rendered.keys.length > 1
-        to_be_rendered.keys.sort.each do |setting|
-          output << "#{setting} = #{to_be_rendered[setting]}\n"
-        end
-      else
-        output << "#{to_be_rendered.to_a[0].last}\n"
-      end
-      output
-    end
-  end
-  def stringifyhash(hash)
-    newhash = {}
-    hash.each do |key, val|
-      key = key.to_s
-      if val.is_a? Hash
-        newhash[key] = stringifyhash(val)
-      elsif val.is_a? Symbol
-        newhash[key] = val.to_s
-      else
-        newhash[key] = val
-      end
-    end
-    newhash
-  end
-  def warn_default_section(section_name)
-    messages = []
-    messages << _("No section specified; defaulting to '%{section_name}'.") %
-      { section_name: section_name }
-    #TRANSLATORS '--section' is a command line option and should not be translated
-    messages << _("Set the config section by using the `--section` flag.")
-    #TRANSLATORS `puppet config --section user print foo` is a command line example and should not be translated
-    messages << _("For example, `puppet config --section user print foo`.")
-    messages << _("For more information, see https://puppet.com/docs/puppet/latest/configuration.html")
-    Puppet.warning(messages.join("\n"))
-  end
-  def report_section_and_environment(section_name, environment_name)
-      $stderr.puts colorize(:hyellow,
-        _("Resolving settings from section '%{section_name}' in environment '%{environment_name}'") %
-          { section_name: section_name, environment_name: environment_name })
-  end
-  action(:set) do
-    summary _("Set Puppet's settings.")
-    arguments _("[setting_name] [setting_value]")
-    description <<-'EOT'
-      Updates values in the `puppet.conf` configuration file.
-    EOT
-    notes <<-'EOT'
-      By default, this action manipulates the configuration in the
-      'main' section. Use the '--section' flag to manipulate other
-      configuration domains.
-    EOT
-    examples <<-'EOT'
-      Set puppet's runfile directory:
-      $ puppet config set rundir /var/run/puppetlabs
-      Set the vardir for only the agent:
-      $ puppet config set vardir /opt/puppetlabs/puppet/cache --section agent
-    EOT
-    when_invoked do |name, value, options|
-      @default_section = false
-      if options[:section] == DEFAULT_SECTION_MARKER
-        options[:section] = DEFAULT_SECTION
-        @default_section = true
-      end
-      if name == 'environment' && options[:section] == 'main'
-        Puppet.warning _(<<-EOM).chomp
-The environment should be set in either the `[user]`, `[agent]`, or `[master]`
-section. Variables set in the `[agent]` section are used when running
-`puppet agent`. Variables set in the `[user]` section are used when running
-various other puppet subcommands, like `puppet apply` and `puppet module`; these
-require the defined environment directory to exist locally. Set the config
-section by using the `--section` flag. For example,
-`puppet config --section user set environment foo`. For more information, see
-https://puppet.com/docs/puppet/latest/configuration.html#environment
-        EOM
-      end
-      if Puppet::Util::Log.sendlevel?(:info)
-        report_section_and_environment(options[:section], Puppet.settings[:environment])
-      end
-      path = Puppet::FileSystem.pathname(Puppet.settings.which_configuration_file)
-      Puppet::FileSystem.touch(path)
-      Puppet::FileSystem.open(path, nil, 'r+:UTF-8') do |file|
-        Puppet::Settings::IniFile.update(file) do |config|
-          config.set(options[:section], name, value)
-        end
-      end
-      nil
-    end
-  end
-  action(:delete) do
-    summary _("Delete a Puppet setting.")
-    arguments _("(<setting>")
-    #TRANSLATORS 'main' is a specific section name and should not be translated
-    description "Deletes a setting from the specified section. (The default is the section 'main')."
-    notes <<-'EOT'
-      By default, this action deletes the configuration setting from the 'main'
-      configuration domain. Use the '--section' flags to delete settings from other
-      configuration domains.
-    EOT
-    examples <<-'EOT'
-      Delete the setting 'setting_name' from the 'main' configuration domain:
-      $ puppet config delete setting_name
-      Delete the setting 'setting_name' from the 'master' configuration domain:
-      $ puppet config delete setting_name --section master
-    EOT
-    when_invoked do |name, options|
-      @default_section = false
-      if options[:section] == DEFAULT_SECTION_MARKER
-        options[:section] = DEFAULT_SECTION
-        @default_section = true
-      end
-      path = Puppet::FileSystem.pathname(Puppet.settings.which_configuration_file)
-      if Puppet::FileSystem.exist?(path)
-        Puppet::FileSystem.open(path, nil, 'r+:UTF-8') do |file|
-          Puppet::Settings::IniFile.update(file) do |config|
-            setting_string = config.delete(options[:section], name)
-            if setting_string
-              if Puppet::Util::Log.sendlevel?(:info)
-                report_section_and_environment(options[:section], Puppet.settings[:environment])
-              end
-              puts(_("Deleted setting from '%{section_name}': '%{setting_string}'") %
-                       { section_name: options[:section], name: name, setting_string: setting_string.strip })
-            else
-              Puppet.warning(_("No setting found in configuration file for section '%{section_name}' setting name '%{name}'") %
-                                 { section_name: options[:section], name: name })
-            end
-          end
-        end
-      else
-        #TRANSLATORS the 'puppet.conf' is a specific file and should not be translated
-        Puppet.warning(_("The puppet.conf file does not exist %{puppet_conf}") % { puppet_conf: path })
-      end
-      nil
-    end
-  end
-end

data/vendored/puppet/lib/puppet/face/epp.rb DELETED

@@ -1,554 +0,0 @@
-require 'puppet/face'
-require 'puppet/pops'
-require 'puppet/parser/files'
-require 'puppet/file_system'
-Puppet::Face.define(:epp, '0.0.1') do
-  copyright "Puppet Inc.", 2014
-  license   _("Apache 2 license; see COPYING")
-  summary _("Interact directly with the EPP template parser/renderer.")
-  action(:validate) do
-    summary _("Validate the syntax of one or more EPP templates.")
-    arguments _("[<template>] [<template> ...]")
-    returns _("Nothing, or encountered syntax errors.")
-    description <<-'EOT'
-      This action validates EPP syntax without producing any output.
-      When validating, multiple issues per file are reported up
-      to the settings of max_error, and max_warnings. The processing
-      stops after having reported issues for the first encountered file with errors
-      unless the option --continue_on_error is given.
-      Files can be given using the `modulename/template.epp` style to lookup the
-      template from a module, or be given as a reference to a file. If the reference
-      to a file can be resolved against a template in a module, the module version
-      wins - in this case use an absolute path to reference the template file
-      if the module version is not wanted.
-      Exits with 0 if there were no validation errors.
-    EOT
-    option("--[no-]continue_on_error") do
-      summary _("Whether or not to continue after errors are reported for a template.")
-    end
-    examples <<-'EOT'
-      Validate the template 'template.epp' in module 'mymodule':
-          $ puppet epp validate mymodule/template.epp
-      Validate two arbitrary template files:
-          $ puppet epp validate mymodule/template1.epp yourmodule/something.epp
-        Validate a template somewhere in the file system:
-            $ puppet epp validate /tmp/testing/template1.epp
-         Validate a template against a file relative to the current directory:
-           $ puppet epp validate template1.epp
-           $ puppet epp validate ./template1.epp
-      Validate from STDIN:
-          $ cat template.epp | puppet epp validate
-      Continue on error to see errors for all templates:
-          $ puppet epp validate mymodule/template1.epp mymodule/template2.epp --continue_on_error
-    EOT
-    when_invoked do |*args|
-      options = args.pop
-      # pass a dummy node, as facts are not needed for validation
-      options[:node] = Puppet::Node.new("testnode", :facts => Puppet::Node::Facts.new("facts", {}))
-      compiler = create_compiler(options)
-      status = true # no validation error yet
-      files = args
-      if files.empty?
-        if not STDIN.tty?
-          tmp = validate_template_string(STDIN.read)
-          status &&= tmp
-        else
-          # This is not an error since a validate of all files in an empty
-          # directory should not be treated as a failed validation.
-          Puppet.notice _("No template specified. No action taken")
-        end
-      end
-      missing_files = []
-      files.each do |file|
-        break if !status && !options[:continue_on_error]
-        template_file = effective_template(file, compiler.environment)
-        if template_file
-          tmp = validate_template(template_file)
-          status &&= tmp
-        else
-          missing_files << file
-        end
-      end
-      if !missing_files.empty?
-        raise Puppet::Error, _("One or more file(s) specified did not exist:\n%{missing_files_list}") %
-            { missing_files_list: missing_files.map { |f| "   #{f}" }.join("\n") }
-      else
-        # Exit with 1 if there were errors
-        raise Puppet::Error, _("Errors while validating epp") unless status
-      end
-    end
-  end
-  action (:dump) do
-    summary _("Outputs a dump of the internal template parse tree for debugging")
-    arguments "[--format <old|pn|json>] [--pretty] { -e <source> | [<templates> ...] } "
-    returns _("A dump of the resulting AST model unless there are syntax or validation errors.")
-    description <<-'EOT'
-      The dump action parses and validates the EPP syntax and dumps the resulting AST model
-      in a human readable (but not necessarily an easy to understand) format.
-      The output format can be controlled using the --format <old|pn|json> where:
-      * 'old' is the default, but now deprecated format which is not API.
-      * 'pn' is the Puppet Extended S-Expression Notation.
-      * 'json' outputs the same graph as 'pn' but with JSON syntax.
-      The output will be "pretty printed" when the option --pretty is given together with --format 'pn' or 'json'.
-      This option has no effect on the 'old' format.
-      The command accepts one or more templates (.epp) files, or an -e followed by the template
-      source text. The given templates can be paths to template files, or references
-      to templates in modules when given on the form <modulename>/<template-name>.epp.
-      If no arguments are given, the stdin is read (unless it is attached to a terminal)
-      If multiple templates are given, they are separated with a header indicating the
-      name of the template. This can be suppressed with the option --no-header.
-      The option --[no-]header has no effect when a single template is dumped.
-      When debugging the epp parser itself, it may be useful to suppress the validation
-      step with the `--no-validate` option to observe what the parser produced from the
-      given source.
-      This command ignores the --render-as setting/option.
-    EOT
-    option("--e " + _("<source>")) do
-      default_to { nil }
-      summary _("Dump one epp source expression given on the command line.")
-    end
-    option("--[no-]validate") do
-      summary _("Whether or not to validate the parsed result, if no-validate only syntax errors are reported.")
-    end
-    option('--format ' + _('<old, pn, or json>')) do
-      summary _("Get result in 'old' (deprecated format), 'pn' (new format), or 'json' (new format in JSON).")
-    end
-    option('--pretty') do
-      summary _('Pretty print output. Only applicable together with --format pn or json')
-    end
-    option("--[no-]header") do
-      summary _("Whether or not to show a file name header between files.")
-    end
-    when_invoked do |*args|
-      require 'puppet/pops'
-      options = args.pop
-      # pass a dummy node, as facts are not needed for dump
-      options[:node] = Puppet::Node.new("testnode", :facts => Puppet::Node::Facts.new("facts", {}))
-      options[:header] = options[:header].nil? ? true : options[:header]
-      options[:validate] = options[:validate].nil? ? true : options[:validate]
-      compiler = create_compiler(options)
-      # Print to a buffer since the face needs to return the resulting string
-      # and the face API is "all or nothing"
-      #
-      buffer = StringIO.new
-      if options[:e]
-        buffer.print dump_parse(options[:e], 'command-line-string', options, false)
-      elsif args.empty?
-        if ! STDIN.tty?
-          buffer.print dump_parse(STDIN.read, 'stdin', options, false)
-        else
-          raise Puppet::Error, _("No input to parse given on command line or stdin")
-        end
-      else
-        templates, missing_files = args.reduce([[],[]]) do |memo, file|
-          template_file = effective_template(file, compiler.environment)
-          if template_file.nil?
-            memo[1] << file
-          else
-            memo[0] << template_file
-          end
-          memo
-        end
-        show_filename = templates.count > 1
-        templates.each do |file|
-          buffer.print dump_parse(Puppet::FileSystem.read(file, :encoding => 'utf-8'), file, options, show_filename)
-        end
-        if !missing_files.empty?
-          raise Puppet::Error, _("One or more file(s) specified did not exist:\n%{missing_files_list}") %
-              { missing_files_list:  missing_files.collect { |f| "   #{f}" }.join("\n") }
-        end
-      end
-      buffer.string
-    end
-  end
-  action (:render) do
-    summary _("Renders an epp template as text")
-    arguments "-e <source> | [<templates> ...] "
-    returns _("A rendered result of one or more given templates.")
-    description <<-'EOT'
-      This action renders one or more EPP templates.
-      The command accepts one or more templates (.epp files), given the same way as templates
-      are given to the puppet `epp` function (a full path, or a relative reference
-      on the form '<modulename>/<template-name>.epp'), or as a relative path.args In case
-      the given path matches both a modulename/template and a file, the template from
-      the module is used.
-      An inline_epp equivalent can also be performed by giving the template after
-      an -e, or by piping the EPP source text to the command.
-      Values to the template can be defined using the Puppet Language on the command
-      line with `--values` or in a .pp or .yaml file referenced with `--values_file`. If
-      specifying both the result is merged with --values having higher precedence.
-      The --values option allows a Puppet Language sequence of expressions to be defined on the
-      command line the same way as it may be given in a .pp file referenced with `--values_file`.
-      It may set variable values (that become available in the template), and must produce
-      either `undef` or a `Hash` of values (the hash may be empty). Producing `undef` simulates
-      that the template is called without an arguments hash and thus only references
-      variables in its outer scope. When a hash is given, a template is limited to seeing
-      only the global scope. It is thus possible to simulate the different types of
-      calls to the `epp` and `inline_epp` functions, with or without a given hash. Note that if
-      variables are given, they are always available in this simulation - to test that the
-      template only references variables given as arguments, produce a hash in --values or
-      the --values_file, do not specify any variables that are not global, and
-      turn on --strict_variables setting.
-      If multiple templates are given, the same set of values are given to each template.
-      If both --values and --value_file are used, the --values are merged on top of those given
-      in the file.
-      When multiple templates are rendered, a separating header is output between the templates
-      showing the name of the template before the output. The header output can be turned off with
-      `--no-header`. This also concatenates the template results without any added newline separators.
-      Facts from the node where the command is being run are used by default.args Facts can be obtained
-      for other nodes if they have called in, and reported their facts by using the `--node <nodename>`
-      flag.
-      Overriding node facts as well as additional facts can be given in a .yaml or .json file and referencing
-      it with the --facts option. (Values can be obtained in yaml format directly from
-      `facter`, or from puppet for a given node). Note that it is not possible to simulate the
-      reserved variable name `$facts` in any other way.
-      Note that it is not possible to set variables using the Puppet Language that have the same
-      names as facts as this result in an error; "attempt to redefine a variable" since facts
-      are set first.
-      Exits with 0 if there were no validation errors. On errors, no rendered output is produced for
-      that template file.
-      When designing EPP templates, it is strongly recommended to define all template arguments
-      in the template, and to give them in a hash when calling `epp` or `inline_epp` and to use
-      as few global variables as possible, preferably only the $facts hash. This makes templates
-      more free standing and are easier to reuse, and to test.
-    EOT
-    examples <<-'EOT'
-      Render the template in module 'mymodule' called 'mytemplate.epp', and give it two arguments
-      `a` and `b`:
-          $ puppet epp render mymodule/mytemplate.epp --values '{a => 10, b => 20}'
-      Render a template using an absolute path:
-          $ puppet epp render /tmp/testing/mytemplate.epp --values '{a => 10, b => 20}'
-      Render a template with data from a .pp file:
-          $ puppet epp render /tmp/testing/mytemplate.epp --values_file mydata.pp
-      Render a template with data from a .pp file and override one value on the command line:
-          $ puppet epp render /tmp/testing/mytemplate.epp --values_file mydata.pp --values '{a=>10}'
-      Render from STDIN:
-          $ cat template.epp | puppet epp render --values '{a => 10, b => 20}'
-      Set variables in a .pp file and render a template that uses variable references:
-          # data.pp file
-          $greeted = 'a global var'
-          undef
-          $ puppet epp render -e 'hello <%= $greeted %>' --values_file data.pp
-      Render a template that outputs a fact:
-          $ facter --yaml > data.yaml
-          $ puppet epp render -e '<% $facts[osfamily] %>' --facts data.yaml
-    EOT
-    option("--node " + _("<node_name>")) do
-      summary _("The name of the node for which facts are obtained. Defaults to facts for the local node.")
-    end
-    option("--e " + _("<source>")) do
-      default_to { nil }
-      summary _("Render one inline epp template given on the command line.")
-    end
-    option("--values " + _("<values_hash>")) do
-      summary _("A Hash in Puppet DSL form given as arguments to the template being rendered.")
-    end
-    option("--values_file " + _("<pp_or_yaml_file>")) do
-      summary _("A .pp or .yaml file that is processed to produce a hash of values for the template.")
-    end
-    option("--facts " + _("<facts_file>")) do
-      summary _("A .yaml or .json file containing a hash of facts made available in $facts and $trusted")
-    end
-    option("--[no-]header") do
-      summary _("Whether or not to show a file name header between rendered results.")
-    end
-    when_invoked do |*args|
-      options = args.pop
-      options[:header] = options[:header].nil? ? true : options[:header]
-      compiler = create_compiler(options)
-      compiler.with_context_overrides('For rendering epp') do
-        # Print to a buffer since the face needs to return the resulting string
-        # and the face API is "all or nothing"
-        #
-        buffer = StringIO.new
-        status = true
-        if options[:e]
-          buffer.print render_inline(options[:e], compiler, options)
-        elsif args.empty?
-          if ! STDIN.tty?
-            buffer.print render_inline(STDIN.read, compiler, options)
-          else
-            raise Puppet::Error, _("No input to process given on command line or stdin")
-          end
-        else
-          show_filename = args.count > 1
-          file_nbr = 0
-          args.each do |file|
-            begin
-              buffer.print render_file(file, compiler, options, show_filename, file_nbr += 1)
-            rescue Puppet::ParseError => detail
-              Puppet.err(detail.message)
-              status = false
-            end
-          end
-        end
-        raise Puppet::Error, _("error while rendering epp") unless status
-        buffer.string
-      end
-    end
-  end
-  def dump_parse(source, filename, options, show_filename = true)
-    output = ""
-    evaluating_parser = Puppet::Pops::Parser::EvaluatingParser::EvaluatingEppParser.new
-    begin
-      if options[:validate]
-        parse_result = evaluating_parser.parse_string(source, filename)
-      else
-        # side step the assert_and_report step
-        parse_result = evaluating_parser.parser.parse_string(source)
-      end
-      if show_filename && options[:header]
-        output << "--- #{filename}\n"
-      end
-      fmt = options[:format]
-      if fmt.nil? || fmt == 'old'
-        output << Puppet::Pops::Model::ModelTreeDumper.new.dump(parse_result) << "\n"
-      else
-        require 'puppet/pops/pn'
-        pn = Puppet::Pops::Model::PNTransformer.transform(parse_result)
-        case fmt
-        when 'json'
-          options[:pretty] ? JSON.pretty_unparse(pn.to_data) : JSON.dump(pn.to_data)
-        else
-          pn.format(options[:pretty] ? Puppet::Pops::PN::Indent.new('  ') : nil, output)
-        end
-      end
-    rescue Puppet::ParseError => detail
-      if show_filename
-        Puppet.err("--- #{filename}")
-      end
-      Puppet.err(detail.message)
-      ""
-    end
-  end
-  def get_values(compiler, options)
-    template_values = nil
-    if values_file = options[:values_file]
-      begin
-        if values_file =~ /\.yaml$/
-          template_values = Puppet::Util::Yaml.safe_load_file(values_file, [Symbol])
-        elsif values_file =~ /\.pp$/
-          evaluating_parser = Puppet::Pops::Parser::EvaluatingParser.new
-          template_values = evaluating_parser.evaluate_file(compiler.topscope, values_file)
-        else
-          Puppet.err(_("Only .yaml or .pp can be used as a --values_file"))
-        end
-      rescue => e
-        Puppet.err(_("Could not load --values_file %{error}") % { error: e.message })
-      end
-      if !(template_values.nil? || template_values.is_a?(Hash))
-        Puppet.err(_("--values_file option must evaluate to a Hash or undef/nil, got: '%{template_class}'") % { template_class: template_values.class })
-      end
-    end
-    if values = options[:values]
-      evaluating_parser = Puppet::Pops::Parser::EvaluatingParser.new
-      result = evaluating_parser.evaluate_string(compiler.topscope, values, 'values-hash')
-      case result
-      when nil
-        template_values
-      when Hash
-        template_values.nil? ? result : template_values.merge(result)
-      else
-        Puppet.err(_("--values option must evaluate to a Hash or undef, got: '%{values_class}'") % { values_class: result.class })
-      end
-    else
-      template_values
-    end
-  end
-  def render_inline(epp_source, compiler, options)
-    template_args = get_values(compiler, options)
-    Puppet::Pops::Evaluator::EppEvaluator.inline_epp(compiler.topscope, epp_source, template_args)
-  end
-  def render_file(epp_template_name, compiler, options, show_filename, file_nbr)
-    template_args = get_values(compiler, options)
-    output = ""
-    begin
-      if show_filename && options[:header]
-        output << "\n" unless file_nbr == 1
-        output << "--- #{epp_template_name}\n"
-      end
-      # Change to an absolute file only if reference is to a an existing file. Note that an absolute file must be used
-      # or the template must be found on the module path when calling the epp evaluator.
-      template_file = Puppet::Parser::Files.find_template(epp_template_name, compiler.environment)
-      if template_file.nil? && Puppet::FileSystem.exist?(epp_template_name)
-        epp_template_name = File.expand_path(epp_template_name)
-      end
-      output << Puppet::Pops::Evaluator::EppEvaluator.epp(compiler.topscope, epp_template_name, compiler.environment, template_args)
-    rescue Puppet::ParseError => detail
-      Puppet.err("--- #{epp_template_name}") if show_filename
-      raise detail
-    end
-    output
-  end
-  # @api private
-  def validate_template(template)
-    parser = Puppet::Pops::Parser::EvaluatingParser::EvaluatingEppParser.new()
-    parser.parse_file(template)
-    true
-  rescue => detail
-    Puppet.log_exception(detail)
-    false
-  end
-  # @api private
-  def validate_template_string(source)
-    parser = Puppet::Pops::Parser::EvaluatingParser::EvaluatingEppParser.new()
-    parser.parse_string(source, '<stdin>')
-    true
-  rescue => detail
-    Puppet.log_exception(detail)
-    false
-  end
-  # @api private
-  def create_compiler(options)
-    if options[:node]
-      node = options[:node]
-    else
-      node = Puppet[:node_name_value]
-      # If we want to lookup the node we are currently on
-      # we must returning these settings to their default values
-      Puppet.settings[:facts_terminus] = 'facter'
-      Puppet.settings[:node_cache_terminus] = nil
-    end
-    unless node.is_a?(Puppet::Node)
-      node = Puppet::Node.indirection.find(node)
-      # Found node must be given the environment to use in some cases, use the one configured
-      # or given on the command line
-      node.environment = Puppet[:environment]
-    end
-    fact_file = options[:facts]
-    if fact_file
-      if fact_file.is_a?(Hash) # when used via the Face API
-        given_facts = fact_file
-      elsif fact_file.end_with?("json")
-        given_facts = Puppet::Util::Json.load(Puppet::FileSystem.read(fact_file, :encoding => 'utf-8'))
-      else
-        given_facts = Puppet::Util::Yaml.safe_load_file(fact_file)
-      end
-      unless given_facts.instance_of?(Hash)
-        raise _("Incorrect formatted data in %{fact_file} given via the --facts flag") % { fact_file: fact_file }
-      end
-      # It is difficult to add to or modify the set of facts once the node is created
-      # as changes does not show up in parameters. Rather than manually patching up
-      # a node and risking future regressions, a new node is created from scratch
-      node = Puppet::Node.new(node.name, :facts => Puppet::Node::Facts.new("facts", node.facts.values.merge(given_facts)))
-      node.environment = Puppet[:environment]
-      node.merge(node.facts.values)
-    end
-    compiler = Puppet::Parser::Compiler.new(node)
-    # configure compiler with facts and node related data
-    # Set all global variables from facts
-    compiler.send(:set_node_parameters)
-    # pretend that the main class (named '') has been evaluated
-    # since it is otherwise not possible to resolve top scope variables
-    # using '::' when rendering. (There is no harm doing this for the other actions)
-    #
-    compiler.topscope.class_set('', compiler.topscope)
-    compiler
-  end
-  # Produces the effective template file from a module/template or file reference
-  # @api private
-  def effective_template(file, env)
-    template_file = Puppet::Parser::Files.find_template(file, env)
-    if !template_file.nil?
-      template_file
-    elsif Puppet::FileSystem.exist?(file)
-      file
-    else
-      nil
-    end
-  end
-end