r10k 3.5.2

data/lib/r10k/logging/terminaloutputter.rb

@@ -0,0 +1,36 @@
+require 'colored2'
+require 'r10k/logging'
+require 'log4r/outputter/iooutputter'
+
+module R10K
+  module Logging
+    class TerminalOutputter < Log4r::IOOutputter
+
+      COLORS = [
+        nil,
+        :cyan,
+        :cyan,
+        :green,
+        nil,
+        nil,
+        :yellow,
+        :red,
+        :red,
+      ]
+
+      attr_accessor :use_color
+
+      private
+
+      def format(logevent)
+        string = super
+        if @use_color
+          color = COLORS[logevent.level]
+          color ? string.send(color) : string
+        else
+          string
+        end
+      end
+    end
+  end
+end

data/lib/r10k/module.rb

@@ -0,0 +1,38 @@
+require 'r10k'
+
+module R10K::Module
+
+  # Register an module implementation for later generation
+  def self.register(klass)
+    @klasses ||= []
+    @klasses << klass
+  end
+
+  # Look up the implementing class and instantiate an object
+  #
+  # This method takes the arguments for normal object generation and checks all
+  # inheriting classes to see if they implement the behavior needed to create
+  # the requested object. It selects the first class that can implement an object
+  # with `name, args`, and generates an object of that class.
+  #
+  # @param [String] name The unique name of the module
+  # @param [String] basedir The root to install the module in
+  # @param [Object] args An arbitary value or set of values that specifies the implementation
+  # @param [R10K::Environment] environment Optional environment that this module is a part of
+  #
+  # @return [Object < R10K::Module] A member of the implementing subclass
+  def self.new(name, basedir, args, environment=nil)
+    if implementation = @klasses.find { |klass| klass.implement?(name, args) }
+      obj = implementation.new(name, basedir, args, environment)
+      obj
+    else
+      raise _("Module %{name} with args %{args} doesn't have an implementation. (Are you using the right arguments?)") % {name: name, args: args.inspect}
+    end
+  end
+
+  require 'r10k/module/base'
+  require 'r10k/module/git'
+  require 'r10k/module/svn'
+  require 'r10k/module/local'
+  require 'r10k/module/forge'
+end

data/lib/r10k/module/base.rb

@@ -0,0 +1,113 @@
+require 'r10k/module'
+require 'puppet_forge'
+
+# This class defines a common interface for module implementations.
+class R10K::Module::Base
+
+  # @!attribute [r] title
+  #   @return [String] The forward slash separated owner and name of the module
+  attr_reader :title
+
+  # @!attribute [r] name
+  #   @return [String] The name of the module
+  attr_reader :name
+
+  # @param [r] dirname
+  #   @return [String] The name of the directory containing this module
+  attr_reader :dirname
+
+  # @deprecated
+  alias :basedir :dirname
+
+  # @!attribute [r] owner
+  #   @return [String, nil] The owner of the module if one is specified
+  attr_reader :owner
+
+  # @!attribute [r] path
+  #   @return [Pathname] The full path of the module
+  attr_reader :path
+
+  # @!attribute [r] environment
+  #   @return [R10K::Environment, nil] The parent environment of the module
+  attr_reader :environment
+
+  # @!attribute [rw] origin
+  #   @return [String] Where the module was sourced from. E.g., "Puppetfile"
+  attr_accessor :origin
+
+  # There's been some churn over `author` vs `owner` and `full_name` over
+  # `title`, so in the short run it's easier to support both and deprecate one
+  # later.
+  alias :author :owner
+  alias :full_name :title
+
+  # @param title [String]
+  # @param dirname [String]
+  # @param args [Array]
+  def initialize(title, dirname, args, environment=nil)
+    @title   = PuppetForge::V3.normalize_name(title)
+    @dirname = dirname
+    @args    = args
+    @owner, @name = parse_title(@title)
+    @path = Pathname.new(File.join(@dirname, @name))
+    @environment = environment
+    @origin = 'external' # Expect Puppetfile or R10k::Environment to set this to a specific value
+  end
+
+  # @deprecated
+  # @return [String] The full filesystem path to the module.
+  def full_path
+    path.to_s
+  end
+
+  # Synchronize this module with the indicated state.
+  # @abstract
+  def sync(opts={})
+    raise NotImplementedError
+  end
+
+  # Return the desired version of this module
+  # @abstract
+  def version
+    raise NotImplementedError
+  end
+
+  # Return the status of the currently installed module.
+  #
+  # This can return the following values:
+  #
+  #   * :absent - there is no module installed
+  #   * :mismatched - there is a module installed but it must be removed and reinstalled
+  #   * :outdated - the correct module is installed but it needs to be updated
+  #   * :insync - the correct module is installed and up to date, or the module is actually a boy band.
+  #
+  # @return [Symbol]
+  # @abstract
+  def status
+    raise NotImplementedError
+  end
+
+  def accept(visitor)
+    visitor.visit(:module, self)
+  end
+
+  # Return the properties of the module
+  #
+  # @return [Hash]
+  # @abstract
+  def properties
+    raise NotImplementedError
+  end
+
+  private
+
+  def parse_title(title)
+    if (match = title.match(/\A(\w+)\Z/))
+      [nil, match[1]]
+    elsif (match = title.match(/\A(\w+)[-\/](\w+)\Z/))
+      [match[1], match[2]]
+    else
+      raise ArgumentError, _("Module name (%{title}) must match either 'modulename' or 'owner/modulename'") % {title: title}
+    end
+  end
+end

data/lib/r10k/module/forge.rb

@@ -0,0 +1,177 @@
+require 'r10k/module'
+require 'r10k/errors'
+require 'r10k/module/metadata_file'
+
+require 'r10k/forge/module_release'
+
+require 'pathname'
+require 'fileutils'
+require 'puppet_forge/util'
+
+class R10K::Module::Forge < R10K::Module::Base
+
+  R10K::Module.register(self)
+
+  def self.implement?(name, args)
+    !!(name.match %r[\w+[/-]\w+]) && valid_version?(args)
+  end
+
+  def self.valid_version?(expected_version)
+    expected_version == :latest || expected_version.nil? || PuppetForge::Util.version_valid?(expected_version)
+  end
+
+  # @!attribute [r] metadata
+  #   @api private
+  #   @return [PuppetForge::Metadata]
+  attr_reader :metadata
+
+  # @!attribute [r] v3_module
+  #   @api private
+  #   @return [PuppetForge::V3::Module] The Puppet Forge module metadata
+  attr_reader :v3_module
+
+  include R10K::Logging
+
+  def initialize(title, dirname, expected_version, environment=nil)
+    super
+
+    @metadata_file = R10K::Module::MetadataFile.new(path + 'metadata.json')
+    @metadata = @metadata_file.read
+
+    @expected_version = expected_version || current_version || :latest
+    @v3_module = PuppetForge::V3::Module.new(:slug => @title)
+  end
+
+  def sync(opts={})
+    case status
+    when :absent
+      install
+    when :outdated
+      upgrade
+    when :mismatched
+      reinstall
+    end
+  end
+
+  def properties
+    {
+      :expected => expected_version,
+      :actual   => current_version,
+      :type     => :forge,
+    }
+  end
+
+  # @return [String] The expected version that the module
+  def expected_version
+    if @expected_version == :latest
+      begin
+        @expected_version = @v3_module.current_release.version
+      rescue Faraday::ResourceNotFound => e
+        raise PuppetForge::ReleaseNotFound, _("The module %{title} does not exist on %{url}.") % {title: @title, url: PuppetForge::V3::Release.conn.url_prefix}, e.backtrace
+      end
+    end
+    @expected_version
+  end
+
+  # @return [String] The version of the currently installed module
+  def current_version
+    if insync?
+      (@metadata ||= @metadata_file.read).nil? ? nil : @metadata.version
+    else
+      nil
+    end
+  end
+
+  alias version current_version
+
+  def exist?
+    path.exist?
+  end
+
+  def insync?
+    status == :insync
+  end
+
+  def deprecated?
+    begin
+      @v3_module.fetch && @v3_module.has_attribute?('deprecated_at') && !@v3_module.deprecated_at.nil?
+    rescue Faraday::ResourceNotFound => e
+      raise PuppetForge::ReleaseNotFound, _("The module %{title} does not exist on %{url}.") % {title: @title, url: PuppetForge::V3::Release.conn.url_prefix}, e.backtrace
+    end
+  end
+
+  # Determine the status of the forge module.
+  #
+  # @return [Symbol] :absent If the directory doesn't exist
+  # @return [Symbol] :mismatched If the module is not a forge module, or
+  #   isn't the right forge module
+  # @return [Symbol] :mismatched If the module was previously a git checkout
+  # @return [Symbol] :outdated If the installed module is older than expected
+  # @return [Symbol] :insync If the module is in the desired state
+  def status
+    if not self.exist?
+      # The module is not installed
+      return :absent
+    elsif not File.exist?(@path + 'metadata.json')
+      # The directory exists but doesn't have a metadata file; it probably
+      # isn't a forge module.
+      return :mismatched
+    end
+
+    if File.directory?(@path + '.git')
+      return :mismatched
+    end
+
+    # The module is present and has a metadata file, read the metadata to
+    # determine the state of the module.
+    @metadata = @metadata_file.read(@path + 'metadata.json')
+
+    if not @title.tr('/','-') == @metadata.full_module_name.tr('/','-')
+
+      # This is a forge module but the installed module is a different author
+      # than the expected author.
+      return :mismatched
+    end
+
+    if expected_version && (expected_version != @metadata.version)
+      return :outdated
+    end
+
+    return :insync
+  end
+
+  def install
+    if deprecated?
+      logger.warn "Puppet Forge module '#{@v3_module.slug}' has been deprecated, visit https://forge.puppet.com/#{@v3_module.slug.tr('-','/')} for more information."
+    end
+
+    parent_path = @path.parent
+    if !parent_path.exist?
+      parent_path.mkpath
+    end
+    module_release = R10K::Forge::ModuleRelease.new(@title, expected_version)
+    module_release.install(@path)
+  end
+
+  alias upgrade install
+
+  def uninstall
+    FileUtils.rm_rf full_path
+  end
+
+  def reinstall
+    uninstall
+    install
+  end
+
+  private
+
+  # Override the base #parse_title to ensure we have a fully qualified name
+  def parse_title(title)
+    if (match = title.match(/\A(\w+)[-\/](\w+)\Z/))
+      [match[1], match[2]]
+    else
+      raise ArgumentError, _("Forge module names must match 'owner/modulename'")
+    end
+  end
+end

data/lib/r10k/module/git.rb

@@ -0,0 +1,109 @@
+require 'r10k/module'
+require 'r10k/git'
+require 'r10k/git/stateful_repository'
+require 'forwardable'
+
+class R10K::Module::Git < R10K::Module::Base
+
+  R10K::Module.register(self)
+
+  def self.implement?(name, args)
+    args.is_a? Hash and args.has_key?(:git)
+  rescue
+    false
+  end
+
+  # @!attribute [r] repo
+  #   @api private
+  #   @return [R10K::Git::StatefulRepository]
+  attr_reader :repo
+
+  # @!attribute [r] desired_ref
+  #   @api private
+  #   @return [String]
+  attr_reader :desired_ref
+
+  # @!attribute [r] default_ref
+  #   @api private
+  #   @return [String]
+  attr_reader :default_ref
+
+  def initialize(title, dirname, args, environment=nil)
+    super
+
+    parse_options(@args)
+
+    @repo = R10K::Git::StatefulRepository.new(@remote, @dirname, @name)
+  end
+
+  def version
+    validate_ref(@desired_ref, @default_ref)
+  end
+
+  def properties
+    {
+      :expected => version,
+      :actual   => (@repo.head || "(unresolvable)"),
+      :type     => :git,
+    }
+  end
+
+  def sync(opts={})
+    force = opts && opts.fetch(:force, true)
+    @repo.sync(version, force)
+  end
+
+  def status
+    @repo.status(version)
+  end
+
+  private
+
+  def validate_ref(desired, default)
+    if desired && desired != :control_branch && @repo.resolve(desired)
+      return desired
+    elsif default && @repo.resolve(default)
+      return default
+    else
+      msg = ["Unable to manage Puppetfile content '%{name}':"]
+      vars = {name: @name}
+
+      if desired == :control_branch
+        msg << "Could not resolve control repo branch"
+      elsif desired
+        msg << "Could not resolve desired ref '%{desired}'"
+        vars[:desired] = desired
+      else
+        msg << "Could not determine desired ref"
+      end
+
+      if default
+        msg << "or resolve default ref '%{default}'"
+        vars[:default] = default
+      else
+        msg << "and no default provided"
+      end
+
+      raise ArgumentError, _(msg.join(' ')) % vars
+    end
+  end
+
+  def parse_options(options)
+    ref_opts = [:branch, :tag, :commit, :ref]
+    known_opts = [:git, :default_branch] + ref_opts
+
+    unhandled = options.keys - known_opts
+    unless unhandled.empty?
+      raise ArgumentError, _("Unhandled options %{unhandled} specified for %{class}") % {unhandled: unhandled, class: self.class}
+    end
+
+    @remote = options[:git]
+
+    @desired_ref = ref_opts.find { |key| break options[key] if options.has_key?(key) } || 'master'
+    @default_ref = options[:default_branch]
+
+    if @desired_ref == :control_branch && @environment && @environment.respond_to?(:ref)
+      @desired_ref = @environment.ref
+    end
+  end
+end