bolt 0.19.1 → 0.20.0

data/vendored/puppet/lib/puppet/face/module/list.rb

@@ -1,268 +0,0 @@
-# encoding: UTF-8
-
-Puppet::Face.define(:module, '1.0.0') do
-  action(:list) do
-    summary _("List installed modules")
-    description <<-HEREDOC
-      Lists the installed puppet modules. By default, this action scans the
-      modulepath from puppet.conf's `[main]` block; use the --modulepath
-      option to change which directories are scanned.
-
-      The output of this action includes information from the module's
-      metadata, including version numbers and unmet module dependencies.
-    HEREDOC
-    returns _("hash of paths to module objects")
-
-    option "--tree" do
-      summary _("Whether to show dependencies as a tree view")
-    end
-
-    option '--strict-semver' do
-      summary _('Whether version ranges should exclude pre-release versions')
-    end
-
-    examples <<-'EOT'
-      List installed modules:
-
-      $ puppet module list
-        /etc/puppetlabs/code/modules
-        ├── bodepd-create_resources (v0.0.1)
-        ├── puppetlabs-bacula (v0.0.2)
-        ├── puppetlabs-mysql (v0.0.1)
-        ├── puppetlabs-sqlite (v0.0.1)
-        └── puppetlabs-stdlib (v2.2.1)
-        /opt/puppetlabs/puppet/modules (no modules installed)
-
-      List installed modules in a tree view:
-
-      $ puppet module list --tree
-        /etc/puppetlabs/code/modules
-        └─┬ puppetlabs-bacula (v0.0.2)
-          ├── puppetlabs-stdlib (v2.2.1)
-          ├─┬ puppetlabs-mysql (v0.0.1)
-          │ └── bodepd-create_resources (v0.0.1)
-          └── puppetlabs-sqlite (v0.0.1)
-        /opt/puppetlabs/puppet/modules (no modules installed)
-
-      List installed modules from a specified environment:
-
-      $ puppet module list --environment production
-        /etc/puppetlabs/code/modules
-        ├── bodepd-create_resources (v0.0.1)
-        ├── puppetlabs-bacula (v0.0.2)
-        ├── puppetlabs-mysql (v0.0.1)
-        ├── puppetlabs-sqlite (v0.0.1)
-        └── puppetlabs-stdlib (v2.2.1)
-        /opt/puppetlabs/puppet/modules (no modules installed)
-
-      List installed modules from a specified modulepath:
-
-      $ puppet module list --modulepath /opt/puppetlabs/puppet/modules
-        /opt/puppetlabs/puppet/modules (no modules installed)
-    EOT
-
-    when_invoked do |options|
-      Puppet::ModuleTool.set_option_defaults(options)
-      environment = options[:environment_instance]
-
-      {
-        :environment     => environment,
-        :modules_by_path => environment.modules_by_path,
-      }
-    end
-
-    when_rendering :console do |result, options|
-      environment     = result[:environment]
-      modules_by_path = result[:modules_by_path]
-
-      output = ''
-
-      environment.modules_strict_semver = !!options[:strict_semver]
-      warn_unmet_dependencies(environment)
-
-      environment.modulepath.each do |path|
-        modules = modules_by_path[path]
-        no_mods = modules.empty? ? _(' (no modules installed)') : ''
-        output << "#{path}#{no_mods}\n"
-
-        if options[:tree]
-          # The modules with fewest things depending on them will be the
-          # parent of the tree.  Can't assume to start with 0 dependencies
-          # since dependencies may be cyclical.
-          modules_by_num_requires = modules.sort_by {|m| m.required_by.size}
-          @seen = {}
-          tree = list_build_tree(modules_by_num_requires, [], nil,
-            :label_unmet => true, :path => path, :label_invalid => false)
-        else
-          tree = []
-          modules.sort_by { |mod| mod.forge_name or mod.name  }.each do |mod|
-            tree << list_build_node(mod, path, :label_unmet => false,
-                      :path => path, :label_invalid => true)
-          end
-        end
-
-        output << Puppet::ModuleTool.format_tree(tree)
-      end
-
-      output
-    end
-  end
-
-  def warn_unmet_dependencies(environment)
-    error_types = [:non_semantic_version, :version_mismatch, :missing]
-
-    @unmet_deps = {}
-    error_types.each do |type|
-      @unmet_deps[type] = Hash.new do |hash, key|
-        hash[key] = { :errors => [], :parent => nil }
-      end
-    end
-
-    # Prepare the unmet dependencies for display on the console.
-    environment.modules.sort_by {|mod| mod.name}.each do |mod|
-      unmet_grouped = Hash.new { |h,k| h[k] = [] }
-      unmet_grouped = mod.unmet_dependencies.inject(unmet_grouped) do |acc, dep|
-        acc[dep[:reason]] << dep
-        acc
-      end
-      unmet_grouped.each do |type, deps|
-        unless deps.empty?
-          unmet_grouped[type].sort_by { |dep| dep[:name] }.each do |dep|
-            dep_name           = dep[:name].gsub('/', '-')
-            installed_version  = dep[:mod_details][:installed_version]
-            version_constraint = dep[:version_constraint]
-            parent_name        = dep[:parent][:name].gsub('/', '-')
-            parent_version     = dep[:parent][:version]
-
-            msg = _("'%{parent_name}' (%{parent_version}) requires '%{dependency_name}' (%{dependency_version})") % { parent_name: parent_name, parent_version: parent_version, dependency_name: dep_name, dependency_version: version_constraint }
-            @unmet_deps[type][dep[:name]][:errors] << msg
-            @unmet_deps[type][dep[:name]][:parent] = {
-              :name    => dep[:parent][:name],
-              :version => parent_version
-            }
-            @unmet_deps[type][dep[:name]][:version] = installed_version
-          end
-        end
-      end
-    end
-
-    # Display unmet dependencies by category.
-    error_display_order = [:non_semantic_version, :version_mismatch, :missing]
-    error_display_order.each do |type|
-      unless @unmet_deps[type].empty?
-        @unmet_deps[type].keys.sort.each do |dep|
-          name    = dep.gsub('/', '-')
-          errors  = @unmet_deps[type][dep][:errors]
-          version = @unmet_deps[type][dep][:version]
-
-          msg = case type
-                when :version_mismatch
-                  _("Module '%{name}' (v%{version}) fails to meet some dependencies:\n") % { name: name, version: version }
-                when :non_semantic_version
-                  _("Non semantic version dependency %{name} (v%{version}):\n") % { name: name, version: version }
-                else
-                  _("Missing dependency '%{name}':\n") % { name: name }
-                end
-
-          errors.each { |error_string| msg << "  #{error_string}\n" }
-          Puppet.warning msg.chomp
-        end
-      end
-    end
-  end
-
-  # Prepare a list of module objects and their dependencies for print in a
-  # tree view.
-  #
-  # Returns an Array of Hashes
-  #
-  # Example:
-  #
-  #   [
-  #     {
-  #       :text => "puppetlabs-bacula (v0.0.2)",
-  #       :dependencies=> [
-  #         { :text => "puppetlabs-stdlib (v2.2.1)", :dependencies => [] },
-  #         {
-  #           :text => "puppetlabs-mysql (v1.0.0)"
-  #           :dependencies => [
-  #             {
-  #               :text => "bodepd-create_resources (v0.0.1)",
-  #               :dependencies => []
-  #             }
-  #           ]
-  #         },
-  #         { :text => "puppetlabs-sqlite (v0.0.1)", :dependencies => [] },
-  #       ]
-  #     }
-  #   ]
-  #
-  # When the above data structure is passed to Puppet::ModuleTool.build_tree
-  # you end up with something like this:
-  #
-  #   /etc/puppetlabs/code/modules
-  #   └─┬ puppetlabs-bacula (v0.0.2)
-  #     ├── puppetlabs-stdlib (v2.2.1)
-  #     ├─┬ puppetlabs-mysql (v1.0.0)
-  #     │ └── bodepd-create_resources (v0.0.1)
-  #     └── puppetlabs-sqlite (v0.0.1)
-  #
-  def list_build_tree(list, ancestors=[], parent=nil, params={})
-    list.map do |mod|
-      next if @seen[(mod.forge_name or mod.name)]
-      node = list_build_node(mod, parent, params)
-      @seen[(mod.forge_name or mod.name)] = true
-
-      unless ancestors.include?(mod)
-        node[:dependencies] ||= []
-        missing_deps = mod.unmet_dependencies.select do |dep|
-          dep[:reason] == :missing
-        end
-        missing_deps.map do |mis_mod|
-          str = "#{colorize(:bg_red, _('UNMET DEPENDENCY'))} #{mis_mod[:name].gsub('/', '-')} "
-          str << "(#{colorize(:cyan, mis_mod[:version_constraint])})"
-          node[:dependencies] << { :text => str }
-        end
-        node[:dependencies] += list_build_tree(mod.dependencies_as_modules,
-          ancestors + [mod], mod, params)
-      end
-
-      node
-    end.compact
-  end
-
-  # Prepare a module object for print in a tree view.  Each node in the tree
-  # must be a Hash in the following format:
-  #
-  #    { :text => "puppetlabs-mysql (v1.0.0)" }
-  #
-  # The value of a module's :text is affected by three (3) factors: the format
-  # of the tree, its dependency status, and the location in the modulepath
-  # relative to its parent.
-  #
-  # Returns a Hash
-  #
-  def list_build_node(mod, parent, params)
-    str = ''
-    str << (mod.forge_name ? mod.forge_name.gsub('/', '-') : mod.name)
-    str << ' (' + colorize(:cyan, mod.version ? "v#{mod.version}" : '???') + ')'
-
-    unless File.dirname(mod.path) == params[:path]
-      str << " [#{File.dirname(mod.path)}]"
-    end
-
-    if @unmet_deps[:version_mismatch].include?(mod.forge_name)
-      if params[:label_invalid]
-        str << '  ' + colorize(:red, _('invalid'))
-      elsif parent.respond_to?(:forge_name)
-        unmet_parent = @unmet_deps[:version_mismatch][mod.forge_name][:parent]
-        if (unmet_parent[:name] == parent.forge_name &&
-            unmet_parent[:version] == "v#{parent.version}")
-          str << '  ' + colorize(:red, _('invalid'))
-        end
-      end
-    end
-
-    { :text => str }
-  end
-end

data/vendored/puppet/lib/puppet/face/module/search.rb

@@ -1,98 +0,0 @@
-require 'puppet/util/terminal'
-require 'puppet/forge'
-
-Puppet::Face.define(:module, '1.0.0') do
-  action(:search) do
-    summary _("Search the Puppet Forge for a module.")
-    description <<-EOT
-      Searches a repository for modules whose names, descriptions, or keywords
-      match the provided search term.
-    EOT
-
-    returns _("Array of module metadata hashes")
-
-    examples <<-EOT
-      Search the Puppet Forge for a module:
-
-      $ puppet module search puppetlabs
-      NAME          DESCRIPTION                          AUTHOR             KEYWORDS
-      bacula        This is a generic Apache module      @puppetlabs        backups
-    EOT
-
-    arguments _("<search_term>")
-
-    when_invoked do |term, options|
-      Puppet::ModuleTool.set_option_defaults options
-      Puppet::ModuleTool::Applications::Searcher.new(term, Puppet::Forge.new(options[:module_repository] || Puppet[:module_repository], options[:strict_semver]), options).run
-    end
-
-    when_rendering :console do |results, term, options|
-      if results[:result] == :failure
-        raise results[:error][:multiline]
-      end
-
-      return _("No results found for '%{term}'.") % { term: term } if results[:answers].empty?
-
-      padding = '  '
-      headers = {
-        'full_name' => 'NAME',
-        'desc'      => 'DESCRIPTION',
-        'author'    => 'AUTHOR',
-        'tag_list'  => 'KEYWORDS',
-      }
-
-      min_widths = Hash[ *headers.map { |k,v| [k, v.length] }.flatten ]
-      min_widths['full_name'] = min_widths['author'] = 12
-
-      min_width = min_widths.inject(0) { |sum,pair| sum + pair.last } + (padding.length * (headers.length - 1))
-
-      terminal_width = [Puppet::Util::Terminal.width, min_width].max
-
-      columns = results[:answers].inject(min_widths) do |hash, result|
-        deprecated_buffer = result['deprecated_at'].nil? ? 0 : 11 # ' DEPRECATED'.length
-
-        {
-          'full_name' => [ hash['full_name'], result['full_name'].length + deprecated_buffer ].max,
-          'desc'      => [ hash['desc'],      result['desc'].length               ].max,
-          'author'    => [ hash['author'],    "@#{result['author']}".length       ].max,
-          'tag_list'  => [ hash['tag_list'],  result['tag_list'].join(' ').length ].max,
-        }
-      end
-
-      flex_width = terminal_width - columns['full_name'] - columns['author'] - (padding.length * (headers.length - 1))
-      tag_lists = results[:answers].map { |r| r['tag_list'] }
-
-      while (columns['tag_list'] > flex_width / 3)
-        longest_tag_list = tag_lists.sort_by { |tl| tl.join(' ').length }.last
-        break if [ [], [term] ].include? longest_tag_list
-        longest_tag_list.delete(longest_tag_list.sort_by { |t| t == term ? -1 : t.length }.last)
-        columns['tag_list'] =  tag_lists.map { |tl| tl.join(' ').length }.max
-      end
-
-      columns['tag_list'] = [
-        flex_width / 3,
-        tag_lists.map { |tl| tl.join(' ').length }.max,
-      ].max
-      columns['desc'] = flex_width - columns['tag_list']
-
-      format = %w{full_name desc author tag_list}.map do |k|
-        "%-#{ [ columns[k], min_widths[k] ].max }s"
-      end.join(padding) + "\n"
-
-      highlight = proc do |s|
-        s = s.gsub(term, colorize(:green, term))
-        s = s.gsub(term.gsub('/', '-'), colorize(:green, term.gsub('/', '-'))) if term =~ /\//
-        s = s.gsub(' DEPRECATED', colorize(:red, ' DEPRECATED'))
-        s
-      end
-
-      format % [ headers['full_name'], headers['desc'], headers['author'], headers['tag_list'] ] +
-      results[:answers].map do |match|
-        name, desc, author, keywords = %w{full_name desc author tag_list}.map { |k| match[k] }
-        name += ' DEPRECATED' unless match['deprecated_at'].nil?
-        desc = desc[0...(columns['desc'] - 3)] + '...' if desc.length > columns['desc']
-        highlight[format % [ name.sub('/', '-'), desc, "@#{author}", [keywords].flatten.join(' ') ]]
-      end.join
-    end
-  end
-end

data/vendored/puppet/lib/puppet/face/module/uninstall.rb

@@ -1,93 +0,0 @@
-Puppet::Face.define(:module, '1.0.0') do
-  action(:uninstall) do
-    summary _("Uninstall a puppet module.")
-    description <<-EOT
-      Uninstalls a puppet module from the modulepath (or a specific
-      target directory).
-      Note: Module uninstall uses MD5 checksums, which are prohibited on FIPS enabled systems.
-    EOT
-
-    returns _("Hash of module objects representing uninstalled modules and related errors.")
-
-    examples <<-'EOT'
-      Uninstall a module:
-
-      $ puppet module uninstall puppetlabs-ssh
-      Removed /etc/puppetlabs/code/modules/ssh (v1.0.0)
-
-      Uninstall a module from a specific directory:
-
-      $ puppet module uninstall puppetlabs-ssh --modulepath /opt/puppetlabs/puppet/modules
-      Removed /opt/puppetlabs/puppet/modules/ssh (v1.0.0)
-
-      Uninstall a module from a specific environment:
-
-      $ puppet module uninstall puppetlabs-ssh --environment development
-      Removed /etc/puppetlabs/code/environments/development/modules/ssh (v1.0.0)
-
-      Uninstall a specific version of a module:
-
-      $ puppet module uninstall puppetlabs-ssh --version 2.0.0
-      Removed /etc/puppetlabs/code/modules/ssh (v2.0.0)
-    EOT
-
-    arguments _("<name>")
-
-    option "--force", "-f" do
-      summary _("Force uninstall of an installed module.")
-      description <<-EOT
-        Force the uninstall of an installed module even if there are local
-        changes or the possibility of causing broken dependencies.
-      EOT
-    end
-
-    option "--ignore-changes", "-c" do
-      summary _("Ignore any local changes made. (Implied by --force.)")
-      description <<-EOT
-        Uninstall an installed module even if there are local changes to it.  (Implied by --force.)
-      EOT
-    end
-
-    option "--version=" do
-      summary _("The version of the module to uninstall")
-      description <<-EOT
-        The version of the module to uninstall. When using this option, a module
-        matching the specified version must be installed or else an error is raised.
-      EOT
-    end
-
-    option '--strict-semver' do
-      summary _('Whether version ranges should exclude pre-release versions')
-    end
-
-    when_invoked do |name, options|
-      name = name.gsub('/', '-')
-
-      Puppet::ModuleTool.set_option_defaults options
-      message = if options[:version]
-                  module_version = colorize(:cyan, options[:version].sub(/^(?=\d)/, 'v'))
-                  _("Preparing to uninstall '%{name}' (%{module_version}) ...") % { name: name, module_version: module_version }
-                else
-                  _("Preparing to uninstall '%{name}' ...") % { name: name }
-                end
-      Puppet.notice message
-      Puppet::ModuleTool::Applications::Uninstaller.run(name, options)
-    end
-
-    when_rendering :console do |return_value|
-      if return_value[:result] == :failure
-        Puppet.err(return_value[:error][:multiline])
-        exit 1
-      else
-        mod = return_value[:affected_modules].first
-        message = if mod.version
-                    module_version = colorize(:cyan, mod.version.to_s.sub(/^(?=\d)/, 'v'))
-                    _("Removed '%{name}' (%{module_version}) from %{path}") % { name: return_value[:module_name], module_version: module_version, path: mod.modulepath }
-                  else
-                    _("Removed '%{name}' from %{path}") % { name: return_value[:module_name], path: mod.modulepath }
-                  end
-        message
-      end
-    end
-  end
-end