puppet-parse 0.0.1 → 0.0.2

data/lib/vendor/puppet/face/module/install.rb

@@ -0,0 +1,174 @@
+# encoding: UTF-8
+
+Puppet::Face.define(:module, '1.0.0') do
+  action(:install) do
+    summary "Install a module from the Puppet Forge or a release archive."
+    description <<-EOT
+      Installs a module from the Puppet Forge or from a release archive file.
+
+      The specified module will be installed into the directory
+      specified with the `--target-dir` option, which defaults to
+      #{Puppet.settings[:modulepath].split(File::PATH_SEPARATOR).first}.
+    EOT
+
+    returns "Pathname object representing the path to the installed module."
+
+    examples <<-'EOT'
+      Install a module:
+
+      $ puppet module install puppetlabs-vcsrepo
+      Preparing to install into /etc/puppet/modules ...
+      Downloading from http://forge.puppetlabs.com ...
+      Installing -- do not interrupt ...
+      /etc/puppet/modules
+      └── puppetlabs-vcsrepo (v0.0.4)
+
+      Install a module to a specific environment:
+
+      $ puppet module install puppetlabs-vcsrepo --environment development
+      Preparing to install into /etc/puppet/environments/development/modules ...
+      Downloading from http://forge.puppetlabs.com ...
+      Installing -- do not interrupt ...
+      /etc/puppet/environments/development/modules
+      └── puppetlabs-vcsrepo (v0.0.4)
+
+      Install a specific module version:
+
+      $ puppet module install puppetlabs-vcsrepo -v 0.0.4
+      Preparing to install into /etc/puppet/modules ...
+      Downloading from http://forge.puppetlabs.com ...
+      Installing -- do not interrupt ...
+      /etc/puppet/modules
+      └── puppetlabs-vcsrepo (v0.0.4)
+
+      Install a module into a specific directory:
+
+      $ puppet module install puppetlabs-vcsrepo --target-dir=/usr/share/puppet/modules
+      Preparing to install into /usr/share/puppet/modules ...
+      Downloading from http://forge.puppetlabs.com ...
+      Installing -- do not interrupt ...
+      /usr/share/puppet/modules
+      └── puppetlabs-vcsrepo (v0.0.4)
+
+      Install a module into a specific directory and check for dependencies in other directories:
+
+      $ puppet module install puppetlabs-vcsrepo --target-dir=/usr/share/puppet/modules --modulepath /etc/puppet/modules
+      Preparing to install into /usr/share/puppet/modules ...
+      Downloading from http://forge.puppetlabs.com ...
+      Installing -- do not interrupt ...
+      /usr/share/puppet/modules
+      └── puppetlabs-vcsrepo (v0.0.4)
+
+      Install a module from a release archive:
+
+      $ puppet module install puppetlabs-vcsrepo-0.0.4.tar.gz
+      Preparing to install into /etc/puppet/modules ...
+      Downloading from http://forge.puppetlabs.com ...
+      Installing -- do not interrupt ...
+      /etc/puppet/modules
+      └── puppetlabs-vcsrepo (v0.0.4)
+
+      Install a module from a release archive and ignore dependencies:
+
+      $ puppet module install puppetlabs-vcsrepo-0.0.4.tar.gz --ignore-dependencies
+      Preparing to install into /etc/puppet/modules ...
+      Installing -- do not interrupt ...
+      /etc/puppet/modules
+      └── puppetlabs-vcsrepo (v0.0.4)
+
+    EOT
+
+    arguments "<name>"
+
+    option "--force", "-f" do
+      summary "Force overwrite of existing module, if any."
+      description <<-EOT
+        Force overwrite of existing module, if any.
+      EOT
+    end
+
+    option "--target-dir DIR", "-i DIR" do
+      summary "The directory into which modules are installed."
+      description <<-EOT
+        The directory into which modules are installed; defaults to the first
+        directory in the modulepath.
+
+        Specifying this option will change the installation directory, and
+        will use the existing modulepath when checking for dependencies. If
+        you wish to check a different set of directories for dependencies, you
+        must also use the `--environment` or `--modulepath` options.
+      EOT
+    end
+
+    option "--ignore-dependencies" do
+      summary "Do not attempt to install dependencies"
+      description <<-EOT
+        Do not attempt to install dependencies.
+      EOT
+    end
+
+    option "--modulepath MODULEPATH" do
+      default_to { Puppet.settings[:modulepath] }
+      summary "Which directories to look for modules in"
+      description <<-EOT
+        The list of directories to check for modules. When installing a new
+        module, this setting determines where the module tool will look for
+        its dependencies. If the `--target dir` option is not specified, the
+        first directory in the modulepath will also be used as the install
+        directory.
+
+        When installing a module into an environment whose modulepath is
+        specified in puppet.conf, you can use the `--environment` option
+        instead, and its modulepath will be used automatically.
+
+        This setting should be a list of directories separated by the path
+        separator character. (The path separator is `:` on Unix-like platforms
+        and `;` on Windows.)
+      EOT
+    end
+
+    option "--version VER", "-v VER" do
+      summary "Module version to install."
+      description <<-EOT
+        Module version to install; can be an exact version or a requirement string,
+        eg '>= 1.0.3'. Defaults to latest version.
+      EOT
+    end
+
+    option "--environment NAME" do
+      default_to { "production" }
+      summary "The target environment to install modules into."
+      description <<-EOT
+        The target environment to install modules into. Only applicable if
+        multiple environments (with different modulepaths) have been
+        configured in puppet.conf.
+      EOT
+    end
+
+    when_invoked do |name, options|
+      sep = File::PATH_SEPARATOR
+
+      if options[:target_dir]
+        options[:modulepath] = "#{options[:target_dir]}#{sep}#{options[:modulepath]}"
+      end
+
+      Puppet.settings[:modulepath] = options[:modulepath]
+      options[:target_dir] = Puppet.settings[:modulepath].split(sep).first
+      options[:target_dir] = File.expand_path(options[:target_dir])
+
+      Puppet.notice "Preparing to install into #{options[:target_dir]} ..."
+      Puppet::ModuleTool::Applications::Installer.run(name, options)
+    end
+
+    when_rendering :console do |return_value, name, options|
+      if return_value[:result] == :failure
+        Puppet.err(return_value[:error][:multiline])
+        exit 1
+      else
+        tree = Puppet::ModuleTool.build_tree(return_value[:installed_modules], return_value[:install_dir])
+        return_value[:install_dir] + "\n" +
+        Puppet::ModuleTool.format_tree(tree)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,285 @@
+# 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 "--environment NAME" do
+      default_to { "production" }
+      summary "Which environments' modules to list"
+      description <<-EOT
+        Which environments' modules to list.
+      EOT
+    end
+
+    option "--modulepath MODULEPATH" do
+      summary "Which directories to look for modules in"
+      description <<-EOT
+        Which directories to look for modules in; use the system path separator
+        character (`:` on Unix-like systems and `;` on Windows) to specify
+        multiple directories.
+      EOT
+    end
+
+    option "--tree" do
+      summary "Whether to show dependencies as a tree view"
+    end
+
+    examples <<-'EOT'
+      List installed modules:
+
+      $ puppet module list
+        /etc/puppet/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)
+        /usr/share/puppet/modules (no modules installed)
+
+      List installed modules in a tree view:
+
+      $ puppet module list --tree
+        /etc/puppet/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)
+        /usr/share/puppet/modules (no modules installed)
+
+      List installed modules from a specified environment:
+
+      $ puppet module list --environment production
+        /etc/puppet/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)
+        /usr/share/puppet/modules (no modules installed)
+
+      List installed modules from a specified modulepath:
+
+      $ puppet module list --modulepath /usr/share/puppet/modules
+        /usr/share/puppet/modules (no modules installed)
+    EOT
+
+    when_invoked do |options|
+      Puppet[:modulepath] = options[:modulepath] if options[:modulepath]
+      environment = Puppet::Node::Environment.new(options[:environment])
+
+      environment.modules_by_path
+    end
+
+    when_rendering :console do |modules_by_path, options|
+      output = ''
+
+      Puppet[:modulepath] = options[:modulepath] if options[:modulepath]
+      environment = Puppet::Node::Environment.new(options[:production])
+
+      error_types = {
+        :non_semantic_version => {
+          :title => "Non semantic version dependency"
+        },
+        :missing => {
+          :title => "Missing dependency"
+        },
+        :version_mismatch => {
+          :title => "Module '%s' (v%s) fails to meet some dependencies:"
+        }
+      }
+
+      @unmet_deps = {}
+      error_types.each_key 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})"
+              msg << " requires '#{dep_name}' (#{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_by {|dep| dep }.each do |dep|
+            name    = dep.gsub('/', '-')
+            title   = error_types[type][:title]
+            errors  = @unmet_deps[type][dep][:errors]
+            version = @unmet_deps[type][dep][:version]
+
+            msg = case type
+                  when :version_mismatch
+                    title % [name, version] + "\n"
+                  when :non_semantic_version
+                    title + " '#{name}' (v#{version}):\n"
+                  else
+                    title + " '#{name}':\n"
+                  end
+
+            errors.each { |error_string| msg << "  #{error_string}\n" }
+            Puppet.warning msg.chomp
+          end
+        end
+      end
+
+      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
+
+  # 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/puppet/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, it's dependency status, and the location in the modulepath
+  # relative to it's 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/lib/vendor/puppet/face/module/search.rb

@@ -0,0 +1,88 @@
+require 'puppet/util/terminal'
+
+Puppet::Face.define(:module, '1.0.0') do
+  action(:search) do
+    summary "Search the Puppet Forge for a module."
+    description <<-EOT
+      Searches the Puppet Forge 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::Applications::Searcher.run(term, options)
+    end
+
+    when_rendering :console do |results, term, options|
+      return "No results found for '#{term}'." if results.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.inject(min_widths) do |hash, result|
+        {
+          'full_name' => [ hash['full_name'], result['full_name'].length          ].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.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
+      end
+
+      format % [ headers['full_name'], headers['desc'], headers['author'], headers['tag_list'] ] +
+      results.map do |match|
+        name, desc, author, keywords = %w{full_name desc author tag_list}.map { |k| match[k] }
+        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/lib/vendor/puppet/face/module/uninstall.rb

@@ -0,0 +1,86 @@
+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).
+    EOT
+
+    returns "Hash of module objects representing uninstalled modules and related errors."
+
+    examples <<-'EOT'
+      Uninstall a module:
+
+      $ puppet module uninstall puppetlabs-ssh
+      Removed /etc/puppet/modules/ssh (v1.0.0)
+
+      Uninstall a module from a specific directory:
+
+      $ puppet module uninstall puppetlabs-ssh --modulepath /usr/share/puppet/modules
+      Removed /usr/share/puppet/modules/ssh (v1.0.0)
+
+      Uninstall a module from a specific environment:
+
+      $ puppet module uninstall puppetlabs-ssh --environment development
+      Removed /etc/puppet/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/puppet/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 "--environment NAME" do
+      default_to { "production" }
+      summary "The target environment to uninstall modules from."
+      description <<-EOT
+        The target environment to uninstall modules from.
+      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 "--modulepath=" do
+      summary "The target directory to search for modules."
+      description <<-EOT
+        The target directory to search for modules.
+      EOT
+    end
+
+    when_invoked do |name, options|
+      Puppet[:modulepath] = options[:modulepath] if options[:modulepath]
+      name = name.gsub('/', '-')
+
+      Puppet.notice "Preparing to uninstall '#{name}'" << (options[:version] ? " (#{colorize(:cyan, options[:version].sub(/^(?=\d)/, 'v'))})" : '') << " ..."
+      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
+        "Removed '#{return_value[:module_name]}'" <<
+        (mod.version ? " (#{colorize(:cyan, mod.version.to_s.sub(/^(?=\d)/, 'v'))})" : '') <<
+        " from #{mod.modulepath}"
+      end
+    end
+  end
+end