puppet-parse 0.0.1 → 0.0.2

data/lib/vendor/puppet/module_tool/errors/installer.rb

@@ -0,0 +1,90 @@
+module Puppet::ModuleTool::Errors
+
+  class InstallError < ModuleToolError; end
+
+  class AlreadyInstalledError < InstallError
+    def initialize(options)
+      @module_name       = options[:module_name]
+      @installed_version = v(options[:installed_version])
+      @requested_version = v(options[:requested_version])
+      @local_changes     = options[:local_changes]
+      super "'#{@module_name}' (#{@requested_version}) requested; '#{@module_name}' (#{@installed_version}) already installed"
+    end
+
+    def multiline
+      message = []
+      message << "Could not install module '#{@module_name}' (#{@requested_version})"
+      message << "  Module '#{@module_name}' (#{@installed_version}) is already installed"
+      message << "    Installed module has had changes made locally" unless @local_changes.empty?
+      message << "    Use `puppet module upgrade` to install a different version"
+      message << "    Use `puppet module install --force` to re-install only this module"
+      message.join("\n")
+    end
+  end
+
+  class InstallConflictError < InstallError
+    def initialize(options)
+      @requested_module  = options[:requested_module]
+      @requested_version = v(options[:requested_version])
+      @dependency        = options[:dependency]
+      @directory         = options[:directory]
+      @metadata          = options[:metadata]
+      super "'#{@requested_module}' (#{@requested_version}) requested; Installation conflict"
+    end
+
+    def multiline
+      message = []
+      message << "Could not install module '#{@requested_module}' (#{@requested_version})"
+
+      if @dependency
+        message << "  Dependency '#{@dependency[:name]}' (#{v(@dependency[:version])}) would overwrite #{@directory}"
+      else
+        message << "  Installation would overwrite #{@directory}"
+      end
+
+      if @metadata
+        message << "    Currently, '#{@metadata[:name]}' (#{v(@metadata[:version])}) is installed to that directory"
+      end
+
+      message << "    Use `puppet module install --dir <DIR>` to install modules elsewhere"
+
+      if @dependency
+        message << "    Use `puppet module install --ignore-dependencies` to install only this module"
+      else
+        message << "    Use `puppet module install --force` to install this module anyway"
+      end
+
+      message.join("\n")
+    end
+  end
+
+  class MissingPackageError < InstallError
+    def initialize(options)
+      @requested_package = options[:requested_package]
+      super "#{@requested_package} requested; Package #{@requested_package} does not exist"
+    end
+
+    def multiline
+      <<-MSG.strip
+Could not install package #{@requested_package}
+  Package #{@requested_package} does not exist
+      MSG
+    end
+  end
+
+  class MissingInstallDirectoryError < InstallError
+    def initialize(options)
+      @requested_module  = options[:requested_module]
+      @requested_version = options[:requested_version]
+      @directory         = options[:directory]
+      super "'#{@requested_module}' (#{@requested_version}) requested; Directory #{@directory} does not exist"
+    end
+
+    def multiline
+      <<-MSG.strip
+Could not install module '#{@requested_module}' (#{@requested_version})
+  Directory #{@directory} does not exist
+      MSG
+    end
+  end
+end

data/lib/vendor/puppet/module_tool/errors/shared.rb

@@ -0,0 +1,115 @@
+module Puppet::ModuleTool::Errors
+
+  class NoVersionsSatisfyError < ModuleToolError
+    def initialize(options)
+      @requested_name    = options[:requested_name]
+      @requested_version = options[:requested_version]
+      @installed_version = options[:installed_version]
+      @dependency_name   = options[:dependency_name]
+      @conditions        = options[:conditions]
+      @action            = options[:action]
+
+      super "Could not #{@action} '#{@requested_name}' (#{vstring}); module '#{@dependency_name}' cannot satisfy dependencies"
+    end
+
+    def multiline
+      same_mod = @requested_name == @dependency_name
+
+      message = []
+      message << "Could not #{@action} module '#{@requested_name}' (#{vstring})"
+      message << "  No version of '#{@dependency_name}' will satisfy dependencies"
+      message << "    You specified '#{@requested_name}' (#{v(@requested_version)})" if same_mod
+      message += @conditions.select { |c| c[:module] != :you }.sort_by { |c| c[:module] }.map do |c|
+        "    '#{c[:module]}' (#{v(c[:version])}) requires '#{@dependency_name}' (#{v(c[:dependency])})"
+      end
+      message << "    Use `puppet module #{@action} --force` to #{@action} this module anyway" if same_mod
+      message << "    Use `puppet module #{@action} --ignore-dependencies` to #{@action} only this module" unless same_mod
+
+      message.join("\n")
+    end
+  end
+
+  class InvalidDependencyCycleError < ModuleToolError
+    def initialize(options)
+      @module_name       = options[:module_name]
+      @requested_module  = options[:requested_module]
+      @requested_version = options[:requested_version]
+      @conditions        = options[:conditions]
+      @source            = options[:source][1..-1]
+
+      super "'#{@requested_module}' (#{v(@requested_version)}) requested; Invalid dependency cycle"
+    end
+
+    def multiline
+      trace = []
+      trace << "You specified '#{@source.first[:name]}' (#{v(@requested_version)})"
+      trace += @source[1..-1].map { |m| "which depends on '#{m[:name]}' (#{v(m[:version])})" }
+
+      message = []
+      message << "Could not install module '#{@requested_module}' (#{v(@requested_version)})"
+      message << "  No version of '#{@module_name}' will satisfy dependencies"
+      message << trace.map { |s| "    #{s}" }.join(",\n")
+      message << "    Use `puppet module install --force` to install this module anyway"
+
+      message.join("\n")
+    end
+  end
+
+  class NotInstalledError < ModuleToolError
+    def initialize(options)
+      @module_name = options[:module_name]
+      @suggestions = options[:suggestions] || []
+      @action      = options[:action]
+      super "Could not #{@action} '#{@module_name}'; module is not installed"
+    end
+
+    def multiline
+      message = []
+      message << "Could not #{@action} module '#{@module_name}'"
+      message << "  Module '#{@module_name}' is not installed"
+      message += @suggestions.map do |suggestion|
+        "    You may have meant `puppet module #{@action} #{suggestion}`"
+      end
+      message << "    Use `puppet module install` to install this module" if @action == :upgrade
+      message.join("\n")
+    end
+  end
+
+  class MultipleInstalledError < ModuleToolError
+    def initialize(options)
+      @module_name = options[:module_name]
+      @modules     = options[:installed_modules]
+      @action      = options[:action]
+      super "Could not #{@action} '#{@module_name}'; module appears in multiple places in the module path"
+    end
+
+    def multiline
+      message = []
+      message << "Could not #{@action} module '#{@module_name}'"
+      message << "  Module '#{@module_name}' appears multiple places in the module path"
+      message += @modules.map do |mod|
+        "    '#{@module_name}' (#{v(mod.version)}) was found in #{mod.modulepath}"
+      end
+      message << "    Use the `--modulepath` option to limit the search to specific directories"
+      message.join("\n")
+    end
+  end
+
+  class LocalChangesError < ModuleToolError
+    def initialize(options)
+      @module_name       = options[:module_name]
+      @requested_version = options[:requested_version]
+      @installed_version = options[:installed_version]
+      @action            = options[:action]
+      super "Could not #{@action} '#{@module_name}'; module is not installed"
+    end
+
+    def multiline
+      message = []
+      message << "Could not #{@action} module '#{@module_name}' (#{vstring})"
+      message << "  Installed module has had changes made locally"
+      message << "    Use `puppet module #{@action} --force` to #{@action} this module anyway"
+      message.join("\n")
+    end
+  end
+end

data/lib/vendor/puppet/module_tool/errors/uninstaller.rb

@@ -0,0 +1,45 @@
+module Puppet::ModuleTool::Errors
+
+  class UninstallError < ModuleToolError; end
+
+  class NoVersionMatchesError < UninstallError
+    def initialize(options)
+      @module_name = options[:module_name]
+      @modules     = options[:installed_modules]
+      @version     = options[:version_range]
+      super "Could not uninstall '#{@module_name}'; no installed version matches"
+    end
+
+    def multiline
+      message = []
+      message << "Could not uninstall module '#{@module_name}' (#{v(@version)})"
+      message << "  No installed version of '#{@module_name}' matches (#{v(@version)})"
+      message += @modules.map do |mod|
+        "    '#{mod[:name]}' (#{v(mod[:version])}) is installed in #{mod[:path]}"
+      end
+      message.join("\n")
+    end
+  end
+
+  class ModuleIsRequiredError < UninstallError
+    def initialize(options)
+      @module_name       = options[:module_name]
+      @required_by       = options[:required_by]
+      @requested_version = options[:requested_version]
+      @installed_version = options[:installed_version]
+
+      super "Could not uninstall '#{@module_name}'; installed modules still depend upon it"
+    end
+
+    def multiline
+      message = []
+      message << ("Could not uninstall module '#{@module_name}'" << (@requested_version ? " (#{v(@requested_version)})" : ''))
+      message << "  Other installed modules have dependencies on '#{@module_name}' (#{v(@installed_version)})"
+      message += @required_by.map do |mod|
+        "    '#{mod['name']}' (#{v(mod['version'])}) requires '#{@module_name}' (#{v(mod['version_requirement'])})"
+      end
+      message << "    Use `puppet module uninstall --force` to uninstall this module anyway"
+      message.join("\n")
+    end
+  end
+end

data/lib/vendor/puppet/module_tool/errors/upgrader.rb

@@ -0,0 +1,72 @@
+module Puppet::ModuleTool::Errors
+
+  class UpgradeError < ModuleToolError
+    def initialize(msg)
+      @action = :upgrade
+      super
+    end
+  end
+
+  class VersionAlreadyInstalledError < UpgradeError
+    def initialize(options)
+      @module_name       = options[:module_name]
+      @requested_version = options[:requested_version]
+      @installed_version = options[:installed_version]
+      @dependency_name   = options[:dependency_name]
+      @conditions        = options[:conditions]
+      super "Could not upgrade '#{@module_name}'; module is not installed"
+    end
+
+    def multiline
+      message = []
+      message << "Could not upgrade module '#{@module_name}' (#{vstring})"
+      if @conditions.length == 1 && @conditions.last[:version].nil?
+        message << "  The installed version is already the latest version"
+      else
+        message << "  The installed version is already the best fit for the current dependencies"
+        message += @conditions.select { |c| c[:module] == :you && c[:version] }.map do |c|
+          "    You specified '#{@module_name}' (#{v(c[:version])})"
+        end
+        message += @conditions.select { |c| c[:module] != :you }.sort_by { |c| c[:module] }.map do |c|
+           "    '#{c[:module]}' (#{v(c[:version])}) requires '#{@module_name}' (#{v(c[:dependency])})"
+        end
+      end
+      message << "    Use `puppet module install --force` to re-install this module"
+      message.join("\n")
+    end
+  end
+
+  class UnknownModuleError < UpgradeError
+    def initialize(options)
+      @module_name       = options[:module_name]
+      @installed_version = options[:installed_version]
+      @requested_version = options[:requested_version]
+      @repository        = options[:repository]
+      super "Could not upgrade '#{@module_name}'; module is unknown to #{@repository}"
+    end
+
+    def multiline
+      message = []
+      message << "Could not upgrade module '#{@module_name}' (#{vstring})"
+      message << "  Module '#{@module_name}' does not exist on #{@repository}"
+      message.join("\n")
+    end
+  end
+
+  class UnknownVersionError < UpgradeError
+    def initialize(options)
+      @module_name       = options[:module_name]
+      @installed_version = options[:installed_version]
+      @requested_version = options[:requested_version]
+      @repository        = options[:repository]
+      super "Could not upgrade '#{@module_name}' (#{vstring}); module has no versions #{ @requested_version && "matching #{v(@requested_version)} "}published on #{@repository}"
+    end
+
+    def multiline
+      message = []
+      message << "Could not upgrade module '#{@module_name}' (#{vstring})"
+      message << "  No version matching '#{@requested_version || ">= 0.0.0"}' exists on #{@repository}"
+      message.join("\n")
+    end
+  end
+end

data/lib/vendor/puppet/module_tool/errors.rb

@@ -0,0 +1,9 @@
+module Puppet::ModuleTool
+  module Errors
+    require 'puppet/module_tool/errors/base'
+    require 'puppet/module_tool/errors/installer'
+    require 'puppet/module_tool/errors/uninstaller'
+    require 'puppet/module_tool/errors/upgrader'
+    require 'puppet/module_tool/errors/shared'
+  end
+end

data/lib/vendor/puppet/module_tool/metadata.rb

@@ -0,0 +1,141 @@
+module Puppet::ModuleTool
+
+  # = Metadata
+  #
+  # This class provides a data structure representing a module's metadata.
+  # It provides some basic parsing, but other data is injected into it using
+  # +annotate+ methods in other classes.
+  class Metadata
+
+    # The full name of the module, which is a dash-separated combination of the
+    # +username+ and module +name+.
+    attr_reader :full_module_name
+
+    # The name of the user that owns this module.
+    attr_reader :username
+
+    # The name of this module. See also +full_module_name+.
+    attr_reader :name
+
+    # The version of this module.
+    attr_reader :version
+
+    # Instantiate from a hash, whose keys are setters in this class.
+    def initialize(settings={})
+      settings.each do |key, value|
+        send("#{key}=", value)
+      end
+    end
+
+    # Set the full name of this module, and from it, the +username+ and
+    # module +name+.
+    def full_module_name=(full_module_name)
+      @full_module_name = full_module_name
+      @username, @name = Puppet::ModuleTool::username_and_modname_from(full_module_name)
+    end
+
+    # Return an array of the module's Dependency objects.
+    def dependencies
+      return @dependencies ||= []
+    end
+
+    def author
+      @author || @username
+    end
+
+    def author=(author)
+      @author = author
+    end
+
+    def source
+      @source || 'UNKNOWN'
+    end
+
+    def source=(source)
+      @source = source
+    end
+
+    def license
+      @license || 'Apache License, Version 2.0'
+    end
+
+    def license=(license)
+      @license = license
+    end
+
+    def summary
+      @summary || 'UNKNOWN'
+    end
+
+    def summary=(summary)
+      @summary = summary
+    end
+
+    def description
+      @description || 'UNKNOWN'
+    end
+
+    def description=(description)
+      @description = description
+    end
+
+    def project_page
+      @project_page || 'UNKNOWN'
+    end
+
+    def project_page=(project_page)
+      @project_page = project_page
+    end
+
+    # Return an array of the module's Puppet types, each one is a hash
+    # containing :name and :doc.
+    def types
+      return @types ||= []
+    end
+
+    # Return module's file checksums.
+    def checksums
+      return @checksums ||= {}
+    end
+
+    # Return the dashed name of the module, which may either be the
+    # dash-separated combination of the +username+ and module +name+, or just
+    # the module +name+.
+    def dashed_name
+      return [@username, @name].compact.join('-')
+    end
+
+    # Return the release name, which is the combination of the +dashed_name+
+    # of the module and its +version+ number.
+    def release_name
+      return [dashed_name, @version].join('-')
+    end
+
+    # Set the version of this module, ensure a string like '0.1.0' see the
+    # Semantic Versions here: http://semver.org
+    def version=(version)
+      if SemVer.valid?(version)
+        @version = version
+      else
+        raise ArgumentError, "Invalid version format: #{@version} (Semantic Versions are acceptable: http://semver.org)"
+      end
+    end
+
+    # Return the PSON record representing this instance.
+    def to_pson(*args)
+      return {
+        :name         => @full_module_name,
+        :version      => @version,
+        :source       => source,
+        :author       => author,
+        :license      => license,
+        :summary      => summary,
+        :description  => description,
+        :project_page => project_page,
+        :dependencies => dependencies,
+        :types        => types,
+        :checksums    => checksums
+      }.to_pson(*args)
+    end
+  end
+end

data/lib/vendor/puppet/module_tool/modulefile.rb

@@ -0,0 +1,75 @@
+module Puppet::ModuleTool
+
+  # = Modulefile
+  #
+  # This class provides the DSL used for evaluating the module's 'Modulefile'.
+  # These methods are used to concisely define this module's attributes, which
+  # are later rendered as PSON into a 'metadata.json' file.
+  class ModulefileReader
+
+    # Read the +filename+ and eval its Ruby code to set values in the Metadata
+    # +metadata+ instance.
+    def self.evaluate(metadata, filename)
+      builder = new(metadata)
+      if File.file?(filename)
+        builder.instance_eval(File.read(filename.to_s), filename.to_s, 1)
+      else
+        Puppet.warning "No Modulefile: #{filename}"
+      end
+      return builder
+    end
+
+    # Instantiate with the Metadata +metadata+ instance.
+    def initialize(metadata)
+      @metadata = metadata
+    end
+
+    # Set the +full_module_name+ (e.g. "myuser-mymodule"), which will also set the
+    # +username+ and module +name+. Required.
+    def name(name)
+      @metadata.full_module_name = name
+    end
+
+    # Set the module +version+ (e.g., "0.0.1"). Required.
+    def version(version)
+      @metadata.version = version
+    end
+
+    # Add a dependency with the full_module_name +name+ (e.g. "myuser-mymodule"), an
+    # optional +version_requirement+ (e.g. "0.0.1") and +repository+ (a URL
+    # string). Optional. Can be called multiple times to add many dependencies.
+    def dependency(name, version_requirement = nil, repository = nil)
+      @metadata.dependencies << Dependency.new(name, version_requirement, repository)
+    end
+
+    # Set the source
+    def source(source)
+      @metadata.source = source
+    end
+
+    # Set the author or default to +username+
+    def author(author)
+        @metadata.author = author
+    end
+
+    # Set the license
+    def license(license)
+      @metadata.license = license
+    end
+
+   # Set the summary
+   def summary(summary)
+      @metadata.summary = summary
+    end
+
+   # Set the description
+   def description(description)
+      @metadata.description = description
+   end
+
+   # Set the project page
+   def project_page(project_page)
+      @metadata.project_page = project_page
+    end
+  end
+end