bolt 0.24.0 → 0.25.0

data/vendored/puppet/lib/puppet/face/facts.rb

@@ -1,87 +0,0 @@
-require 'puppet/indirector/face'
-require 'puppet/node/facts'
-
-Puppet::Indirector::Face.define(:facts, '0.0.1') do
-  copyright "Puppet Inc.", 2011
-  license   _("Apache 2 license; see COPYING")
-
-  summary _("Retrieve and store facts.")
-  description <<-'EOT'
-    This subcommand manages facts, which are collections of normalized system
-    information used by Puppet. It can read facts directly from the local system
-    (with the default `facter` terminus).
-  EOT
-
-  find = get_action(:find)
-  find.summary _("Retrieve a node's facts.")
-  find.arguments _("[<node_certname>]")
-  find.returns <<-'EOT'
-    A hash containing some metadata and (under the "values" key) the set
-    of facts for the requested node. When used from the Ruby API: A
-    Puppet::Node::Facts object.
-
-    RENDERING ISSUES: Facts cannot currently be rendered as a string; use yaml
-    or json.
-  EOT
-  find.notes <<-'EOT'
-    When using the `facter` terminus, the host argument is ignored.
-  EOT
-  find.examples <<-'EOT'
-    Get facts from the local system:
-
-    $ puppet facts find
-  EOT
-  find.default = true
-
-  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/vendored/puppet/lib/puppet/face/generate.rb

@@ -1,64 +0,0 @@
-require 'puppet/face'
-require 'puppet/generate/type'
-
-# Create the Generate face
-Puppet::Face.define(:generate, '0.1.0') do
-  copyright 'Puppet Inc.', 2016
-  license   _('Apache 2 license; see COPYING')
-
-  summary _('Generates Puppet code from Ruby definitions.')
-
-  action(:types) do
-    summary _('Generates Puppet code for custom types')
-
-    description <<-'EOT'
-      Generates definitions for custom resource types using Puppet code.
-
-      Types defined in Puppet code can be used to isolate custom type definitions
-      between different environments.
-    EOT
-
-    examples <<-'EOT'
-      Generate Puppet type definitions for all custom resource types in the current environment:
-
-          $ puppet generate types
-
-      Generate Puppet type definitions for all custom resource types in the specified environment:
-
-          $ puppet generate types --environment development
-    EOT
-
-    option '--format ' + _('<format>') do
-      summary _('The generation output format to use. Supported formats: pcore.')
-      default_to { 'pcore' }
-
-      before_action do |_, _, options|
-        raise ArgumentError, _("'%{format}' is not a supported format for type generation.") % { format: options[:format] } unless ['pcore'].include?(options[:format])
-      end
-    end
-
-    option '--force' do
-      summary _('Forces the generation of output files (skips up-to-date checks).')
-      default_to { false }
-    end
-
-    when_invoked do |options|
-      generator = Puppet::Generate::Type
-      inputs = generator.find_inputs(options[:format].to_sym)
-      environment = Puppet.lookup(:current_environment)
-
-      # get the common output directory (in <envroot>/.resource_types) - create it if it does not exists
-      # error if it exists and is not a directory
-      #
-      path_to_env = environment.configuration.path_to_env
-      outputdir = File.join(path_to_env, '.resource_types')
-      if Puppet::FileSystem.exist?(outputdir) && !Puppet::FileSystem.directory?(outputdir)
-        raise ArgumentError, _("The output directory '%{outputdir}' exists and is not a directory") % { outputdir: outputdir }
-      end
-      Puppet::FileSystem::mkpath(outputdir)
-
-      generator.generate(inputs, outputdir, options[:force])
-      nil
-    end
-  end
-end

data/vendored/puppet/lib/puppet/face/help.rb

@@ -1,215 +0,0 @@
-require 'puppet/face'
-require 'puppet/application/face_base'
-require 'puppet/util/constant_inflector'
-require 'pathname'
-require 'erb'
-
-Puppet::Face.define(:help, '0.0.1') do
-  copyright "Puppet Inc.", 2011
-  license   _("Apache 2 license; see COPYING")
-
-  summary _("Display Puppet help.")
-
-  action(:help) do
-    summary _("Display help about Puppet subcommands and their actions.")
-    arguments _("[<subcommand>] [<action>]")
-    returns _("Short help text for the specified subcommand or action.")
-    examples _(<<-'EOT')
-      Get help for an action:
-
-      $ puppet help
-    EOT
-
-    option "--version " + _("VERSION") do
-      summary _("The version of the subcommand for which to show help.")
-    end
-
-    default
-    when_invoked do |*args|
-      options = args.pop
-
-      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
-        if options[:version].to_s !~ /^current$/i
-          version = options[:version]
-        else
-          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
-
-      facename, actionname = args
-      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
-        return render_face_help(facename, actionname, version)
-      end
-    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
-    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
-    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 ! action
-        fail ArgumentError, _("Unable to load action %{actionname} from %{face}") % { actionname: actionname, face: face }
-      end
-    end
-
-    [face, action]
-  end
-
-  def template_for(face, action)
-    if action.nil?
-      erb('face.erb')
-    else
-      erb('action.erb')
-    end
-  end
-
-  def erb(name)
-    template = (Pathname(__FILE__).dirname + "help" + name)
-    erb = ERB.new(template.read, nil, '-')
-    erb.filename = template.to_s
-    return erb
-  end
-
-  # Return a list of applications that are not simply just stubs for Faces.
-  def legacy_applications
-    Puppet::Application.available_application_names.reject do |appname|
-      (is_face_app?(appname)) or (exclude_from_docs?(appname))
-    end.sort
-  end
-
-  # Return a list of all applications (both legacy and Face applications), along with a summary
-  #  of their functionality.
-  # @return [Array] An Array of Arrays.  The outer array contains one entry per application; each
-  #  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()
-    available_application_names_special_sort().inject([]) do |result, appname|
-      next result if exclude_from_docs?(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, '  ']
-        rescue StandardError, LoadError
-          error_message = _("!%{sub_command}! Subcommand unavailable due to error.") % { sub_command: appname }
-          error_message += ' ' + _("Check error logs.")
-          result << [ error_message, '', '  ' ]
-        end
-      else
-        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)
-    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
-    end
-    return ''
-  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.
-  #  See #14205.
-  #private :horribly_extract_summary_from
-
-  def exclude_from_docs?(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.
-  #  See #14205.
-  #private :exclude_from_docs?
-
-  def is_face_app?(appname)
-    clazz = Puppet::Application.find(appname)
-
-    clazz.ancestors.include?(Puppet::Application::FaceBase)
-  end
-  # This should probably be a private method, but for some reason it appears
-  #  that you can't use the 'private' keyword inside of a Face definition.
-  #  See #14205.
-  #private :is_face_app?
-
-end

data/vendored/puppet/lib/puppet/face/key.rb

@@ -1,16 +0,0 @@
-require 'puppet/indirector/face'
-
-Puppet::Indirector::Face.define(:key, '0.0.1') do
-  copyright "Puppet Inc.", 2011
-  license   _("Apache 2 license; see COPYING")
-
-  summary _("Create, save, and remove certificate keys.")
-  description <<-'EOT'
-    This subcommand manages certificate private keys. Keys are created
-    automatically by puppet agent and when certificate requests are generated
-    with 'puppet certificate generate'; it should not be necessary to use this
-    subcommand directly.
-  EOT
-
-  deprecate
-end

data/vendored/puppet/lib/puppet/face/man.rb

@@ -1,145 +0,0 @@
-require 'puppet/face'
-require 'puppet/util'
-require 'pathname'
-require 'erb'
-
-Puppet::Face.define(:man, '0.0.1') do
-  copyright "Puppet Inc.", 2011
-  license   _("Apache 2 license; see COPYING")
-
-  summary _("Display Puppet manual pages.")
-
-  description <<-EOT
-    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.
-  EOT
-
-  notes <<-EOT
-    The pager used for display will be the first found of `$MANPAGER`, `$PAGER`,
-    `less`, `most`, or `more`.
-  EOT
-
-  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.
-
-      RENDERING ISSUES: To skip fancy formatting and output the raw Markdown
-      text (e.g. for use in a pipeline), call this action with '--render-as s'.
-    EOT
-    examples <<-'EOT'
-      View the installed manual page for the subcommand 'config':
-
-      $ man puppet-config
-
-      (Deprecated) View the manual page for the subcommand 'config':
-
-      $ puppet man config
-    EOT
-
-    default
-    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
-
-      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, '-')
-      erb.filename = file.to_s
-
-      # Run the ERB template in our current binding, including all the local
-      # variables we established just above. --daniel 2011-04-11
-      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,
-      # otherwise we finally just delegate to our parent.  Oh, well.
-
-      # These are the same options for less that git normally uses.
-      # -R : Pass through color control codes (allows display of colors)
-      # -X : Don't init/deinit terminal (leave display on screen on exit)
-      # -F : automatically exit if display fits entirely on one screen
-      # -S : don't wrap long lines
-      ENV['LESS'] ||= 'FRSX'
-
-      ronn  = Puppet::Util.which('ronn')
-      pager = [ENV['MANPAGER'], ENV['PAGER'], 'less', 'most', 'more'].
-        detect {|x| x and x.length > 0 and Puppet::Util.which(x) }
-
-      if ronn
-        # ronn is a stupid about pager selection, we can be smarter. :)
-        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
-        # manual pages could contain UTF-8 text
-        IO.popen(pager, 'w:UTF-8') do |fh| fh.write text end
-        ''
-      else
-        text
-      end
-    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|
-      Puppet::Face.face? appname.to_sym, :current or
-        # ...this is a nasty way to exclude non-applications. :(
-        %w{face_base indirection_base}.include? appname
-    end
-  end
-
-  deprecate
-end