puppet 5.0.0 → 6.0.0

data/lib/puppet/face/epp.rb

@@ -63,7 +63,7 @@ Puppet::Face.define(:epp, '0.0.1') do
     when_invoked do |*args|
       options = args.pop
       # pass a dummy node, as facts are not needed for validation
-      options[:node] = node = Puppet::Node.new("testnode", :facts => Puppet::Node::Facts.new("facts", {}))
+      options[:node] = Puppet::Node.new("testnode", :facts => Puppet::Node::Facts.new("facts", {}))
       compiler = create_compiler(options)
 
       status = true # no validation error yet
@@ -92,7 +92,8 @@ Puppet::Face.define(:epp, '0.0.1') do
         end
       end
       if !missing_files.empty?
-        raise Puppet::Error, _("One or more file(s) specified did not exist:\n") + missing_files.map { |f| "   #{f}" }.join("\n")
+        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
@@ -103,13 +104,19 @@ Puppet::Face.define(:epp, '0.0.1') do
 
   action (:dump) do
     summary _("Outputs a dump of the internal template parse tree for debugging")
-    arguments "-e <source> | [<templates> ...] "
+    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 of the dumped tree is intended for epp parser debugging purposes
-      and is not API, and may thus change between versions without deprecation warnings.
+
+      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
@@ -136,6 +143,14 @@ Puppet::Face.define(:epp, '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
+
     option("--[no-]header") do
       summary _("Whether or not to show a file name header between files.")
     end
@@ -144,7 +159,7 @@ Puppet::Face.define(:epp, '0.0.1') do
       require 'puppet/pops'
       options = args.pop
       # pass a dummy node, as facts are not needed for dump
-      options[:node] = node = Puppet::Node.new("testnode", :facts => Puppet::Node::Facts.new("facts", {}))
+      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]
 
@@ -175,12 +190,13 @@ Puppet::Face.define(:epp, '0.0.1') do
         end
 
         show_filename = templates.count > 1
-        dumps = templates.each do |file|
+        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.collect { |f| "   #{f}" }.join("\n")
+          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
@@ -316,40 +332,41 @@ Puppet::Face.define(:epp, '0.0.1') do
       options[:header] = options[:header].nil? ? true : options[:header]
 
       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
-      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)
+      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
-          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
+          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
-      raise Puppet::Error, _("error while rendering epp") unless status
-      buffer.string
     end
   end
 
   def dump_parse(source, filename, options, show_filename = true)
     output = ""
-    dumper = Puppet::Pops::Model::ModelTreeDumper.new
     evaluating_parser = Puppet::Pops::Parser::EvaluatingParser::EvaluatingEppParser.new
     begin
       if options[:validate]
@@ -361,7 +378,19 @@ Puppet::Face.define(:epp, '0.0.1') do
       if show_filename && options[:header]
         output << "--- #{filename}\n"
       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}")
@@ -376,7 +405,7 @@ Puppet::Face.define(:epp, '0.0.1') do
     if values_file = options[:values_file]
       begin
         if values_file =~ /\.yaml$/
-          template_values = YAML.load_file(values_file)
+          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)
@@ -480,9 +509,9 @@ Puppet::Face.define(:epp, '0.0.1') do
       if fact_file.is_a?(Hash) # when used via the Face API
         given_facts = fact_file
       elsif fact_file.end_with?("json")
-        given_facts = JSON.parse(Puppet::FileSystem.read(fact_file, :encoding => 'utf-8'))
+        given_facts = Puppet::Util::Json.load(Puppet::FileSystem.read(fact_file, :encoding => 'utf-8'))
       else
-        given_facts = YAML.load(Puppet::FileSystem.read(fact_file, :encoding => 'utf-8'))
+        given_facts = Puppet::Util::Yaml.safe_load_file(fact_file)
       end
 
       unless given_facts.instance_of?(Hash)

data/lib/puppet/face/facts.rb

@@ -35,4 +35,53 @@ Puppet::Indirector::Face.define(:facts, '0.0.1') do
 
   deactivate_action(:destroy)
   deactivate_action(:search)
+
+  action(:upload) do
+    summary _("Upload local facts to the puppet master.")
+    description <<-'EOT'
+      Reads facts from the local system using the `facter` terminus, then
+      saves the returned facts using the rest terminus.
+    EOT
+    returns "Nothing."
+    notes <<-'EOT'
+      This action requires that the puppet master's `auth.conf` file
+      allow `PUT` or `save` access to the `/puppet/v3/facts` API endpoint.
+
+      For details on configuring Puppet Server's `auth.conf`, see:
+
+      <https://puppet.com/docs/puppetserver/latest/config_file_auth.html>
+
+      For legacy Rack-based Puppet Masters, see:
+
+      <https://puppet.com/docs/puppet/latest/config_file_auth.html>
+    EOT
+    examples <<-'EOT'
+      Upload facts:
+
+      $ puppet facts upload
+    EOT
+
+    render_as :json
+
+    when_invoked do |options|
+      # Use `agent` sections  settings for certificates, Puppet Server URL,
+      # etc. instead of `user` section settings.
+      Puppet.settings.preferred_run_mode = :agent
+      Puppet::Node::Facts.indirection.terminus_class = :facter
+
+      facts = Puppet::Node::Facts.indirection.find(Puppet[:node_name_value])
+      unless Puppet[:node_name_fact].empty?
+        Puppet[:node_name_value] = facts.values[Puppet[:node_name_fact]]
+        facts.name = Puppet[:node_name_value]
+      end
+
+      Puppet::Node::Facts.indirection.terminus_class = :rest
+      server = Puppet::Node::Facts::Rest.server
+      Puppet.notice(_("Uploading facts for '%{node}' to: '%{server}'") % {
+                    node: Puppet[:node_name_value],
+                    server: server})
+
+      Puppet::Node::Facts.indirection.save(facts)
+    end
+  end
 end

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

@@ -1,4 +1,7 @@
 <%# encoding: UTF-8%>
+<% if action.deprecated? -%>
+  <%= "Warning: 'puppet #{action.face.name} #{action.name}' is deprecated and will be removed in a future release." %>
+<% end %>
 <% if action.synopsis -%>
 USAGE: <%= action.synopsis %>
 
@@ -83,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/help/global.erb

@@ -7,8 +7,8 @@ Available subcommands:
         because faces can't be run without an application stub.  However, when #6753 is resolved,
         all of the application stubs for faces will go away, and this will need to be updated
         to reflect that.  --cprice 2012-04-26 %>
-<% all_application_summaries.each do |appname, summary| -%>
-  <%= appname.to_s.ljust(16) %>  <%= summary %>
+<% all_application_summaries.each do |appname, summary, indent| -%>
+  <%= indent %><%= appname.to_s.ljust(16) %>  <%= summary %>
 <% end -%>
 
 See 'puppet help <subcommand> <action>' for help on a specific subcommand action.

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

@@ -23,7 +23,7 @@ settings, so you can specify `--server <servername>`, or
 `--run_mode <runmode>` as an argument.
 
 See the configuration file documentation at
-<https://docs.puppetlabs.com/puppet/latest/reference/configuration.html> for the
+<https://puppet.com/docs/puppet/latest/configuration.html> for the
 full list of acceptable parameters. A commented list of all
 configuration options can also be generated by running puppet with
 `--genconfig`.

data/lib/puppet/face/help.rb

@@ -26,47 +26,33 @@ Puppet::Face.define(:help, '0.0.1') do
 
     default
     when_invoked do |*args|
-      # Check our invocation, because we want varargs and can't do defaults
-      # yet.  REVISIT: when we do option defaults, and positional options, we
-      # should rewrite this to use those. --daniel 2011-04-04
       options = args.pop
-      if options.nil? or args.length > 2 then
-        if args.select { |x| x == 'help' }.length > 2 then
-          c = "\n %'(),-./=ADEFHILORSTUXY\\_`gnv|".split('')
-          i = <<-'EOT'.gsub(/\s*/, '').to_i(36)
-            3he6737w1aghshs6nwrivl8mz5mu9nywg9tbtlt081uv6fq5kvxse1td3tj1wvccmte806nb
-            cy6de2ogw0fqjymbfwi6a304vd56vlq71atwmqsvz3gpu0hj42200otlycweufh0hylu79t3
-            gmrijm6pgn26ic575qkexyuoncbujv0vcscgzh5us2swklsp5cqnuanlrbnget7rt3956kam
-            j8adhdrzqqt9bor0cv2fqgkloref0ygk3dekiwfj1zxrt13moyhn217yy6w4shwyywik7w0l
-            xtuevmh0m7xp6eoswin70khm5nrggkui6z8vdjnrgdqeojq40fya5qexk97g4d8qgw0hvokr
-            pli1biaz503grqf2ycy0ppkhz1hwhl6ifbpet7xd6jjepq4oe0ofl575lxdzjeg25217zyl4
-            nokn6tj5pq7gcdsjre75rqylydh7iia7s3yrko4f5ud9v8hdtqhu60stcitirvfj6zphppmx
-            7wfm7i9641d00bhs44n6vh6qvx39pg3urifgr6ihx3e0j1ychzypunyou7iplevitkyg6gbg
-            wm08oy1rvogcjakkqc1f7y1awdfvlb4ego8wrtgu9vzw4vmj59utwifn2ejcs569dh1oaavi
-            sc581n7jjg1dugzdu094fdobtx6rsvk3sfctvqnr36xctold
-          EOT
-          353.times{i,x=i.divmod(1184);a,b=x.divmod(37);print(c[a]*b)}
-        end
-        raise ArgumentError, _("Puppet help only takes two (optional) arguments: a subcommand and an action")
+
+      if default_case?(args) || help_for_help?(args)
+        return erb('global.erb').result(binding)
+      end
+
+      if args.length > 2
+        #TRANSLATORS 'puppet help' is a command line and should not be translated
+        raise ArgumentError, _("The 'puppet help' command takes two (optional) arguments: a subcommand and an action")
       end
 
       version = :current
-      if options.has_key? :version then
-        if options[:version].to_s !~ /^current$/i then
+      if options.has_key? :version
+        if options[:version].to_s !~ /^current$/i
           version = options[:version]
         else
-          if args.length == 0 then
-            raise ArgumentError, _("Version only makes sense when a Faces subcommand is given")
+          if args.length == 0
+            #TRANSLATORS '--version' is a command line option and should not be translated
+            raise ArgumentError, _("Supplying a '--version' only makes sense when a Faces subcommand is given")
           end
         end
       end
 
-      return erb('global.erb').result(binding) if args.empty?
-
       facename, actionname = args
-      if legacy_applications.include? facename then
-        if actionname then
-          raise ArgumentError, _("Legacy subcommands don't take actions")
+      if legacy_applications.include? facename
+        if actionname
+          raise ArgumentError, _("The legacy subcommand '%{sub_command}' does not support supplying an action") % { sub_command: facename }
         end
         return render_application_help(facename)
       else
@@ -75,36 +61,42 @@ Puppet::Face.define(:help, '0.0.1') do
     end
   end
 
+  def default_case?(args)
+    args.empty?
+  end
+
+  def help_for_help?(args)
+    args.length == 1 && args.first == 'help'
+  end
+
   def render_application_help(applicationname)
     return Puppet::Application[applicationname].help
   rescue StandardError, LoadError => detail
-    msg = _(<<-MSG) % { applicationname: applicationname, detail: detail.message }
-Could not load help for the application %{applicationname}.
-Please check the error logs for more information.
-
-Detail: "%{detail}"
-MSG
-    fail ArgumentError, msg, detail.backtrace
+    message = []
+    message << _('Could not load help for the application %{application_name}.') % { application_name: applicationname }
+    message << _('Please check the error logs for more information.')
+    message << ''
+    message << _('Detail: "%{detail}"') % { detail: detail.message }
+    fail ArgumentError, message.join("\n"), detail.backtrace
   end
 
   def render_face_help(facename, actionname, version)
     face, action = load_face_help(facename, actionname, version)
     return template_for(face, action).result(binding)
   rescue StandardError, LoadError => detail
-    msg = _(<<-MSG) % { facename: facename, detail: detail.message }
-Could not load help for the face %{facename}.
-Please check the error logs for more information.
-
-Detail: "%{detail}"
-MSG
-    fail ArgumentError, msg, detail.backtrace
+    message = []
+    message << _('Could not load help for the face %{face_name}.') % { face_name: facename }
+    message << _('Please check the error logs for more information.')
+    message << ''
+    message << _('Detail: "%{detail}"') % { detail: detail.message }
+    fail ArgumentError, message.join("\n"), detail.backtrace
   end
 
   def load_face_help(facename, actionname, version)
     face = Puppet::Face[facename.to_sym, version]
     if actionname
       action = face.get_action(actionname.to_sym)
-      if not action
+      if ! action
         fail ArgumentError, _("Unable to load action %{actionname} from %{face}") % { actionname: actionname, face: face }
       end
     end
@@ -140,38 +132,60 @@ MSG
   #  element in the outer array is a pair whose first element is a String containing the application
   #  name, and whose second element is a String containing the summary for that application.
   def all_application_summaries()
-    Puppet::Application.available_application_names.sort.inject([]) do |result, appname|
+    available_application_names_special_sort().inject([]) do |result, appname|
       next result if exclude_from_docs?(appname)
 
-      if (is_face_app?(appname))
+      if (appname == COMMON || appname == SPECIALIZED || appname == BLANK)
+        result << appname
+      elsif (is_face_app?(appname))
         begin
           face = Puppet::Face[appname, :current]
           # Add deprecation message to summary if the face is deprecated
-          summary = face.deprecated? ? face.summary + _(" (Deprecated)") : face.summary
-          result << [appname, summary]
+          summary = face.deprecated? ? face.summary + ' ' + _("(Deprecated)") : face.summary
+          result << [appname, summary, '  ']
         rescue StandardError, LoadError
-          result << [ "! #{appname}", _("! Subcommand unavailable due to error. Check error logs.") ]
+          error_message = _("!%{sub_command}! Subcommand unavailable due to error.") % { sub_command: appname }
+          error_message += ' ' + _("Check error logs.")
+          result << [ error_message, '', '  ' ]
         end
       else
-        result << [appname, horribly_extract_summary_from(appname)]
+        begin
+          summary = Puppet::Application[appname].summary
+          if summary.empty?
+            summary = horribly_extract_summary_from(appname)
+          end
+          result << [appname, summary, '  ']
+        rescue StandardError, LoadError
+          error_message = _("!%{sub_command}! Subcommand unavailable due to error.") % { sub_command: appname }
+          error_message += ' ' + _("Check error logs.")
+          result << [ error_message, '', '  ' ]
+        end
       end
     end
   end
 
+  COMMON = 'Common:'.freeze
+  SPECIALIZED = 'Specialized:'.freeze
+  BLANK = "\n".freeze
+  def available_application_names_special_sort()
+    full_list = Puppet::Application.available_application_names
+    a_list = full_list & %w{apply agent config help lookup module resource}
+    a_list = a_list.sort
+    also_ran = full_list - a_list
+    also_ran = also_ran.sort
+    [[COMMON], a_list, [BLANK], [SPECIALIZED], also_ran].flatten(1)
+  end
+
   def horribly_extract_summary_from(appname)
-    begin
-      help = Puppet::Application[appname].help.split("\n")
-      # Now we find the line with our summary, extract it, and return it.  This
-      # depends on the implementation coincidence of how our pages are
-      # formatted.  If we can't match the pattern we expect we return the empty
-      # string to ensure we don't blow up in the summary. --daniel 2011-04-11
-      while line = help.shift do
-        if md = /^puppet-#{appname}\([^\)]+\) -- (.*)$/.match(line) then
-          return md[1]
-        end
+    help = Puppet::Application[appname].help.split("\n")
+    # Now we find the line with our summary, extract it, and return it.  This
+    # depends on the implementation coincidence of how our pages are
+    # formatted.  If we can't match the pattern we expect we return the empty
+    # string to ensure we don't blow up in the summary. --daniel 2011-04-11
+    while line = help.shift do
+      if md = /^puppet-#{appname}\([^\)]+\) -- (.*)$/.match(line)
+        return md[1]
       end
-    rescue StandardError, LoadError
-      return _("! Subcommand unavailable due to error. Check error logs.")
     end
     return ''
   end
@@ -181,7 +195,7 @@ MSG
   #private :horribly_extract_summary_from
 
   def exclude_from_docs?(appname)
-    %w{face_base indirection_base}.include? appname
+    %w{face_base indirection_base cert key man plugin report status}.include? appname
   end
   # This should absolutely be a private method, but for some reason it appears
   #  that you can't use the 'private' keyword inside of a Face definition.

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.
@@ -25,6 +27,7 @@ Puppet::Face.define(:man, '0.0.1') do
   action(:man) do
     summary _("Display the manual page for a Puppet subcommand.")
     arguments _("<subcommand>")
+    #TRANSLATORS '--render-as s' is a command line option and should not be translated
     returns _(<<-'EOT')
       The man data, in Markdown format, suitable for consumption by Ronn.
 
@@ -32,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, '-')
@@ -54,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,
@@ -71,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
         ''
@@ -90,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|
@@ -98,4 +140,6 @@ Puppet::Face.define(:man, '0.0.1') do
         %w{face_base indirection_base}.include? appname
     end
   end
+
+  deprecate
 end