puppet 5.4.0 → 5.5.0

data/lib/puppet/face/help/action.erb

@@ -86,4 +86,4 @@ undocumented option
 TERMINI: <%= face.class.terminus_classes(face.indirection.name).join(", ") %>
 
 <% end -%>
-See 'puppet man <%= face.name %>' or 'man puppet-<%= face.name %>' for full help.
+See 'puppet help <%= face.name %>' or 'man puppet-<%= face.name %>' for full help.

data/lib/puppet/face/help/face.erb

@@ -111,4 +111,4 @@ end -%>
 TERMINI: <%= face.class.terminus_classes(face.indirection.name).join(", ") %>
 
 <% end -%>
-See 'puppet man <%= face.name %>' or 'man puppet-<%= face.name %>' for full help.
+See 'puppet help <%= face.name %>' or 'man puppet-<%= face.name %>' for full help.

data/lib/puppet/face/man.rb

@@ -10,8 +10,10 @@ Puppet::Face.define(:man, '0.0.1') do
   summary _("Display Puppet manual pages.")
 
   description <<-EOT
-    This subcommand displays manual pages for all Puppet subcommands. If the
-    `ronn` gem (<https://github.com/rtomayko/ronn/>) is installed on your
+    Please use the command 'puppet help <subcommand>' or the system manpage system
+    'man puppet-<subcommand>' to display information about Puppet subcommands. The
+    deprecated man subcommand displays manual pages for all Puppet subcommands. If
+    the `ronn` gem (<https://github.com/rtomayko/ronn/>) is installed on your
     system, puppet man will display fully-formatted man pages. If `ronn` is not
     available, puppet man will display the raw (but human-readable) source text
     in a pager.
@@ -33,18 +35,40 @@ Puppet::Face.define(:man, '0.0.1') do
       text (e.g. for use in a pipeline), call this action with '--render-as s'.
     EOT
     examples <<-'EOT'
-      View the manual page for a subcommand:
+      View the installed manual page for the subcommand 'config':
 
-      $ puppet man facts
+      $ man puppet-config
+
+      (Deprecated) View the manual page for the subcommand 'config':
+
+      $ puppet man config
     EOT
 
     default
-    when_invoked do |name, options|
-      if legacy_applications.include? name then
-        return Puppet::Application[name].help
+    when_invoked do |*args|
+      # 'args' is an array of the subcommand and arguments from the command line and an options hash
+      # [<arg1>, ..., {options}]
+      _options = args.pop
+
+      unless valid_command_line?(args)
+        print_man_help
+        #TRANSLATORS 'puppet man' is a specific command line and should not be translated
+        raise ArgumentError, _("The 'puppet man' command takes a single subcommand to review the subcommand's manpage")
       end
 
-      face = Puppet::Face[name.to_sym, :current]
+      manpage = args.first
+      if default_case?(manpage)
+        print_man_help
+        return nil
+      end
+
+      if legacy_applications.include?(manpage)
+        return Puppet::Application[manpage].help
+      end
+
+      # set 'face' as it's used in the erb processing.
+      face = Puppet::Face[manpage.to_sym, :current]
+      _face = face # suppress the unused variable warning
 
       file = (Pathname(__FILE__).dirname + "help" + 'man.erb')
       erb = ERB.new(file.read, nil, '-')
@@ -55,7 +79,6 @@ Puppet::Face.define(:man, '0.0.1') do
       return erb.result(binding)
     end
 
-
     when_rendering :console do |text|
       # OK, if we have Ronn on the path we can delegate to it and override the
       # normal output process.  Otherwise delegate to a pager on the raw text,
@@ -72,16 +95,16 @@ Puppet::Face.define(:man, '0.0.1') do
       pager = [ENV['MANPAGER'], ENV['PAGER'], 'less', 'most', 'more'].
         detect {|x| x and x.length > 0 and Puppet::Util.which(x) }
 
-      if ronn then
+      if ronn
         # ronn is a stupid about pager selection, we can be smarter. :)
-        if pager then ENV['PAGER'] = pager end
+        ENV['PAGER'] = pager if pager
 
         args  = "--man --manual='Puppet Manual' --organization='Puppet Inc., LLC'"
         # manual pages could contain UTF-8 text
         IO.popen("#{ronn} #{args}", 'w:UTF-8') do |fh| fh.write text end
 
         ''                      # suppress local output, neh?
-      elsif pager then
+      elsif pager
         # manual pages could contain UTF-8 text
         IO.popen(pager, 'w:UTF-8') do |fh| fh.write text end
         ''
@@ -91,6 +114,24 @@ Puppet::Face.define(:man, '0.0.1') do
     end
   end
 
+  def valid_command_line?(args)
+    # not too many arguments
+    # This allows the command line case of "puppet man man man" to not throw an error because face_based eats
+    # one of the "man"'s, which means this command line ends up looking like this in the code: 'manface.man("man")'
+    # However when we generate manpages, we do the same call. So we have to allow it and generate the real manpage.
+    args.length <= 1
+  end
+
+  # by default, if you ask for the man manpage "puppet man man" face_base removes the "man" from the args that we
+  # are passed, so we get nil instead
+  def default_case?(manpage)
+    manpage.nil?
+  end
+
+  def print_man_help
+    puts Puppet::Face[:help, :current].help(:man)
+  end
+
   def legacy_applications
     # The list of applications, less those that are duplicated as a face.
     Puppet::Application.available_application_names.reject do |appname|
@@ -99,4 +140,6 @@ Puppet::Face.define(:man, '0.0.1') do
         %w{face_base indirection_base}.include? appname
     end
   end
+
+  deprecate
 end

data/lib/puppet/face/parser.rb

@@ -64,12 +64,20 @@ Puppet::Face.define(:parser, '0.0.1') do
 
   action (:dump) do
     summary _("Outputs a dump of the internal parse tree for debugging")
-    arguments "-e " + _("<source>| [<manifest> ...] ")
+    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'
       This action parses and validates the Puppet DSL syntax without compiling a catalog
       or syncing any resources.
 
+      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 manifests (.pp) files, or an -e followed by the puppet
       source text.
       If no arguments are given, the stdin is read (unless it is attached to a terminal)
@@ -87,6 +95,14 @@ Puppet::Face.define(:parser, '0.0.1') 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
+
     when_invoked do |*args|
       require 'puppet/pops'
       options = args.pop
@@ -120,7 +136,6 @@ Puppet::Face.define(:parser, '0.0.1') do
 
   def dump_parse(source, filename, options, show_filename = true)
     output = ""
-    dumper = Puppet::Pops::Model::ModelTreeDumper.new
     evaluating_parser = Puppet::Pops::Parser::EvaluatingParser.new
     begin
       if options[:validate]
@@ -132,7 +147,19 @@ Puppet::Face.define(:parser, '0.0.1') do
       if show_filename
         output << "--- #{filename}"
       end
-      output << dumper.dump(parse_result) << "\n"
+      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}")

data/lib/puppet/file_bucket/file.rb

@@ -74,8 +74,6 @@ class Puppet::FileBucket::File
     self.new(contents)
   end
 
-  private
-
   class StringContents
     def initialize(content)
       @contents = content;

data/lib/puppet/file_serving/base.rb

@@ -22,17 +22,17 @@ class Puppet::FileServing::Base
   # Return the full path to our file.  Fails if there's no path set.
   def full_path
     if relative_path.nil? or relative_path == "" or relative_path == "."
-       full_path = path
-     else
-       full_path = File.join(path, relative_path)
-     end
+      full_path = path
+    else
+      full_path = File.join(path, relative_path)
+    end
 
-     if Puppet.features.microsoft_windows?
-       # Replace multiple slashes as long as they aren't at the beginning of a filename
-       full_path.gsub(%r{(./)/+}, '\1')
-     else
-       full_path.gsub(%r{//+}, '/')
-     end
+    if Puppet.features.microsoft_windows?
+      # Replace multiple slashes as long as they aren't at the beginning of a filename
+      full_path.gsub(%r{(./)/+}, '\1')
+    else
+      full_path.gsub(%r{//+}, '/')
+    end
   end
 
   def initialize(path, options = {})

data/lib/puppet/forge.rb

@@ -5,7 +5,7 @@ require 'net/http'
 require 'tempfile'
 require 'uri'
 require 'pathname'
-require 'json'
+require 'puppet/util/json'
 require 'semantic_puppet'
 
 class Puppet::Forge < SemanticPuppet::Dependency::Source
@@ -64,7 +64,7 @@ class Puppet::Forge < SemanticPuppet::Dependency::Source
       response = make_http_request(uri)
 
       if response.code == '200'
-        result = JSON.parse(response.body)
+        result = Puppet::Util::Json.load(response.body)
         uri = decode_uri(result['pagination']['next'])
         matches.concat result['results']
       else
@@ -101,7 +101,7 @@ class Puppet::Forge < SemanticPuppet::Dependency::Source
       response = make_http_request(uri)
 
       if response.code == '200'
-        response = JSON.parse(response.body)
+        response = Puppet::Util::Json.load(response.body)
       else
         raise ResponseError.new(:uri => URI.parse(@host).merge(uri), :response => response)
       end

data/lib/puppet/forge/errors.rb

@@ -1,4 +1,4 @@
-require 'json'
+require 'puppet/util/json'
 require 'puppet/error'
 require 'puppet/forge'
 
@@ -82,11 +82,11 @@ module Puppet::Forge::Errors
       @response = "#{response.code} #{response.message.strip}"
 
       begin
-        body = JSON.parse(response.body)
+        body = Puppet::Util::Json.load(response.body)
         if body['message']
           @message ||= body['message'].strip
         end
-      rescue JSON::ParserError
+      rescue Puppet::Util::Json::ParseError
       end
 
       message = if @message

data/lib/puppet/functions.rb

@@ -564,7 +564,7 @@ module Puppet::Functions
       @block_name = nil
       @return_type = nil
       @argument_mismatch_hander = argument_mismatch_handler
-      self.instance_eval &block
+      self.instance_eval(&block)
       callable_t = create_callable(@types, @block_type, @return_type, @min, @max)
       @dispatcher.add(Puppet::Pops::Functions::Dispatch.new(callable_t, meth_name, @names, @max == :default, @block_name, @injections, @weaving, @argument_mismatch_hander))
     end
@@ -650,8 +650,6 @@ module Puppet::Functions
     end
   end
 
-  private
-
   # @note WARNING: This style of creating functions is not public. It is a system
   #   under development that will be used for creating "system" functions.
   #

data/lib/puppet/functions/alert.rb

@@ -1,4 +1,4 @@
-# Log a message on the server at level alert.
+# Logs a message on the server at level `alert`.
 Puppet::Functions.create_function(:alert, Puppet::Functions::InternalFunction) do
   # @param values The values to log.
   # @return [Undef]

data/lib/puppet/functions/all.rb

@@ -18,11 +18,11 @@
 #
 # @example Using the `all` function with an Array and a one-parameter lambda
 #
-# ~~~ puppet
+# ```puppet
 # # For the array $data, run a lambda that checks that all values are multiples of 10
 # $data = [10, 20, 30]
 # notice $data.all |$item| { $item % 10 == 0 }
-# ~~~
+# ```
 #
 # Would notice `true`.
 #
@@ -31,11 +31,11 @@
 #
 # @example Using the `all` function with a `Hash` and a one-parameter lambda
 #
-# ~~~ puppet
+# ```puppet
 # # For the hash $data, run a lambda using each item as a key-value array
 # $data = { 'a_0'=> 10, 'b_1' => 20 }
 # notice $data.all |$item| { $item[1] % 10 == 0  }
-# ~~~
+# ```
 #
 # Would notice `true` if all values in the hash are multiples of 10.
 #
@@ -45,11 +45,11 @@
 #
 # @example Using the `all` function with a hash and a two-parameter lambda
 #
-# ~~~ puppet
+# ```puppet
 # # Check that all values are a multiple of 10 and keys start with 'abc'
 # $data = {abc_123 => 10, abc_42 => 20, abc_blue => 30}
 # notice $data.all |$key, $value| { $value % 10 == 0  and $key =~ /^abc/ }
-# ~~~
+# ```
 #
 # Would notice true.
 #

data/lib/puppet/functions/annotate.rb

@@ -5,11 +5,11 @@
 #
 # @example Using `annotate` with two arguments
 #
-# ~~~ puppet
+# ```puppet
 # $annotation = Mod::NickNameAdapter.annotate(o)
 #
 # $annotation = annotate(Mod::NickNameAdapter.annotate, o)
-# ~~~
+# ```
 #
 # With three arguments, an `Annotation` type, an object, and a block, the function returns the
 # annotation for the object of the given type, or annotates it with a new annotation initialized
@@ -18,11 +18,11 @@
 #
 # @example Using `annotate` with two arguments and a block
 #
-# ~~~ puppet
+# ```puppet
 # $annotation = Mod::NickNameAdapter.annotate(o) || { { 'nick_name' => 'Buddy' } }
 #
 # $annotation = annotate(Mod::NickNameAdapter.annotate, o) || { { 'nick_name' => 'Buddy' } }
-# ~~~
+# ```
 #
 # With three arguments, an `Annotation` type, an object, and an `Hash`, the function will annotate
 # the given object with a new annotation of the given type that is initialized from the given hash.
@@ -30,11 +30,11 @@
 #
 # @example Using `annotate` with three arguments where third argument is a Hash
 #
-# ~~~ puppet
+# ```puppet
 # $annotation = Mod::NickNameAdapter.annotate(o, { 'nick_name' => 'Buddy' })
 #
 # $annotation = annotate(Mod::NickNameAdapter.annotate, o, { 'nick_name' => 'Buddy' })
-# ~~~
+# ```
 #
 # With three arguments, an `Annotation` type, an object, and an the string `clear`, the function will
 # clear the annotation of the given type in the given object. The old annotation is returned if
@@ -42,11 +42,11 @@
 #
 # @example Using `annotate` with three arguments where third argument is the string 'clear'
 #
-# ~~~ puppet
+# ```puppet
 # $annotation = Mod::NickNameAdapter.annotate(o, clear)
 #
 # $annotation = annotate(Mod::NickNameAdapter.annotate, o, clear)
-# ~~~
+# ```
 #
 # With three arguments, the type `Pcore`, an object, and a Hash of hashes keyed by `Annotation` types,
 # the function will annotate the given object with all types used as keys in the given hash. Each annotation
@@ -54,12 +54,12 @@
 #
 # @example Add multiple annotations to a new instance of `Mod::Person` using the `Pcore` type.
 #
-# ~~~ puppet
+# ```puppet
 #   $person = Pcore.annotate(Mod::Person({'name' => 'William'}), {
 #     Mod::NickNameAdapter >= { 'nick_name' => 'Bill' },
 #     Mod::HobbiesAdapter => { 'hobbies' => ['Ham Radio', 'Philatelist'] }
 #   })
-# ~~~
+# ```
 #
 # @since 5.0.0
 #

data/lib/puppet/functions/any.rb

@@ -18,12 +18,12 @@
 #
 # @example Using the `any` function with an Array and a one-parameter lambda
 #
-# ~~~ puppet
+# ```puppet
 # # For the array $data, run a lambda that checks if an unknown hash contains those keys
 # $data = ["routers", "servers", "workstations"]
 # $looked_up = lookup('somekey', Hash)
 # notice $data.any |$item| { $looked_up[$item] }
-# ~~~
+# ```
 #
 # Would notice `true` if the looked up hash had a value that is neither `false` nor `undef` for at least
 # one of the keys. That is, it is equivalent to the expression
@@ -34,12 +34,12 @@
 #
 # @example Using the `any` function with a `Hash` and a one-parameter lambda
 #
-# ~~~ puppet
+# ```puppet
 # # For the hash $data, run a lambda using each item as a key-value array.
 # $data = {"rtr" => "Router", "svr" => "Server", "wks" => "Workstation"}
 # $looked_up = lookup('somekey', Hash)
 # notice $data.any |$item| { $looked_up[$item[0]] }
-# ~~~
+# ```
 #
 # Would notice `true` if the looked up hash had a value for one of the wanted key that is
 # neither `false` nor `undef`.
@@ -50,11 +50,11 @@
 #
 # @example Using the `any` function with an array and a two-parameter lambda
 #
-# ~~~ puppet
+# ```puppet
 # # Check if there is an even numbered index that has a non String value
 # $data = [key1, 1, 2, 2]
 # notice $data.any |$index, $value| { $index % 2 == 0 and $value !~ String }
-# ~~~
+# ```
 #
 # Would notice true as the index `2` is even and not a `String`
 #