r10k 1.4.2 → 1.5.1

data/lib/r10k/git/shellgit/cache.rb

@@ -0,0 +1,11 @@
+require 'r10k/git/shellgit'
+require 'r10k/git/cache'
+
+class R10K::Git::ShellGit::Cache < R10K::Git::Cache
+
+  @instance_cache = R10K::InstanceCache.new(self)
+
+  def self.bare_repository
+    R10K::Git::ShellGit::BareRepository
+  end
+end

data/lib/r10k/git/shellgit/thin_repository.rb

@@ -0,0 +1,56 @@
+require 'r10k/git/shellgit'
+require 'r10k/git/shellgit/cache'
+require 'r10k/git/shellgit/working_repository'
+
+# Manage a Git working repository backed with cached bare repositories. Instead
+# of duplicating all objects for new clones and updates, this uses Git
+# alternate object databases to reuse objects from an existing repository,
+# making new clones very lightweight.
+class R10K::Git::ShellGit::ThinRepository < R10K::Git::ShellGit::WorkingRepository
+
+  def initialize(basedir, dirname)
+    super
+
+    if exist? && origin
+      set_cache(origin)
+    end
+  end
+
+  # Clone this git repository
+  #
+  # @param remote [String] The Git remote to clone
+  # @param opts [Hash]
+  #
+  # @options opts [String] :ref The git ref to check out on clone
+  #
+  # @return [void]
+  def clone(remote, opts = {})
+    # todo check if opts[:reference] is set
+    set_cache(remote)
+    @cache_repo.sync
+
+    super(remote, opts.merge(:reference => @cache_repo.git_dir.to_s))
+    setup_cache_remote
+  end
+
+  # Fetch refs from the backing bare Git repository.
+  def fetch(remote = 'cache')
+    git ['fetch', remote], :path => @path.to_s
+  end
+
+  # @return [String] The origin remote URL
+  def cache
+    git(['config', '--get', 'remote.cache.url'], :path => @path.to_s, :raise_on_fail => false).stdout
+  end
+
+  private
+
+  def set_cache(remote)
+    @cache_repo = R10K::Git::ShellGit::Cache.generate(remote)
+  end
+
+  def setup_cache_remote
+    git ["remote", "add", "cache", @cache_repo.git_dir.to_s], :path => @path.to_s
+    fetch
+  end
+end

data/lib/r10k/git/shellgit/working_repository.rb

@@ -0,0 +1,73 @@
+require 'r10k/git'
+require 'r10k/git/alternates'
+require 'r10k/git/shellgit/base_repository'
+
+# Manage a non-bare Git repository
+class R10K::Git::ShellGit::WorkingRepository < R10K::Git::ShellGit::BaseRepository
+
+  # @attribute [r] path
+  #   @return [Pathname]
+  attr_reader :path
+
+  # @return [Pathname] The path to the Git directory inside of this repository
+  def git_dir
+    @path + '.git'
+  end
+
+  def initialize(basedir, dirname)
+    @path = Pathname.new(File.join(basedir, dirname))
+  end
+
+  # Clone this git repository
+  #
+  # @param remote [String] The Git remote to clone
+  # @param opts [Hash]
+  #
+  # @options opts [String] :ref The git ref to check out on clone
+  # @options opts [String] :reference A Git repository to use as an alternate object database
+  #
+  # @return [void]
+  def clone(remote, opts = {})
+    argv = ['clone', remote, @path.to_s]
+    if opts[:reference]
+      argv += ['--reference', opts[:reference]]
+    end
+    git argv
+
+    if opts[:ref]
+      checkout(opts[:ref])
+    end
+  end
+
+  # Check out the given Git ref
+  #
+  # @param ref [String] The git reference to check out
+  def checkout(ref)
+    git ['checkout', ref], :path => @path.to_s
+  end
+
+  def fetch
+    git ['fetch'], :path => @path.to_s
+  end
+
+  def exist?
+    @path.exist?
+  end
+
+  # @return [String] The currently checked out ref
+  def head
+    resolve('HEAD')
+  end
+
+  def alternates
+    R10K::Git::Alternates.new(git_dir)
+  end
+
+  # @return [String] The origin remote URL
+  def origin
+    result = git(['config', '--get', 'remote.origin.url'], :path => @path.to_s, :raise_on_fail => false)
+    if result.success?
+      result.stdout
+    end
+  end
+end

data/lib/r10k/git/stateful_repository.rb

@@ -0,0 +1,80 @@
+require 'r10k/git'
+require 'r10k/git/errors'
+require 'forwardable'
+require 'r10k/logging'
+
+# Manage how Git repositories are created and set to specific refs
+class R10K::Git::StatefulRepository
+
+  include R10K::Logging
+
+  # @!attribute [r] repo
+  #   @api private
+  attr_reader :repo
+
+  extend Forwardable
+  def_delegators :@repo, :head
+
+  # Create a new shallow git working directory
+  #
+  # @param ref     [String] The git ref to check out
+  # @param remote  [String] The git remote to use for the repo
+  # @param basedir [String] The path containing the Git repo
+  # @param dirname [String] The directory name of the Git repo
+  def initialize(ref, remote, basedir, dirname)
+    @ref = ref
+    @remote = remote
+
+    @repo = R10K::Git.thin_repository.new(basedir, dirname)
+    @cache = R10K::Git.cache.generate(remote)
+  end
+
+  def sync
+    @cache.sync if sync_cache?
+
+    sha = @cache.resolve(@ref)
+
+    if sha.nil?
+      raise R10K::Git::UnresolvableRefError.new("Unable to sync repo to unresolvable ref '#{@ref}'", :git_dir => @repo.git_dir)
+    end
+
+    case status
+    when :absent
+      logger.debug { "Cloning #{@repo.path} and checking out #{@ref}" }
+      @repo.clone(@remote, {:ref => sha})
+    when :mismatched
+      logger.debug { "Replacing #{@repo.path} and checking out #{@ref}" }
+      @repo.path.rmtree
+      @repo.clone(@remote, {:ref => sha})
+    when :outdated
+      logger.debug { "Updating #{@repo.path} to #{@ref}" }
+      @repo.checkout(sha)
+    else
+      logger.debug { "#{@repo.path} is already at Git ref #{@ref}" }
+    end
+  end
+
+  def status
+    if !@repo.exist?
+      :absent
+    elsif !@repo.git_dir.exist?
+      :mismatched
+    elsif !(@repo.origin == @remote)
+      :mismatched
+    elsif !(@repo.head == @cache.resolve(@ref))
+      :outdated
+    elsif @cache.ref_type(@ref) == :branch && !@cache.synced?
+      :outdated
+    else
+      :insync
+    end
+  end
+
+  # @api private
+  def sync_cache?
+    return true if !@cache.exist?
+    return true if !@cache.resolve(@ref)
+    return true if !([:commit, :tag].include? @cache.ref_type(@ref))
+    return false
+  end
+end

data/lib/r10k/git/tag.rb

@@ -6,6 +6,9 @@ require 'r10k/git/repository'
 # In contrast to a head, a tag is not updated by the commit command. A tag is
 # most typically used to mark a particular point in the commit ancestry chain.
 #
+# @deprecated This has been replaced by the ShellGit provider and the
+#   StatefulRepository class and will be removed in 2.0.0
+#
 # @see https://www.kernel.org/pub/software/scm/git/docs/gitglossary.html
 # @api private
 class R10K::Git::Tag < R10K::Git::Ref

data/lib/r10k/git/working_dir.rb

@@ -2,11 +2,23 @@ require 'forwardable'
 require 'r10k/git'
 require 'r10k/git/cache'
 
+require 'r10k/git/working_dir'
+require 'r10k/git/ref'
+require 'r10k/git/tag'
+require 'r10k/git/head'
+require 'r10k/git/remote_head'
+require 'r10k/git/commit'
+
 # Implements sparse git repositories with shared objects
 #
 # Working directory instances use the git alternatives object store, so that
 # working directories only contain checked out files and all object files are
 # shared.
+#
+# @deprecated This has been replaced by the ShellGit provider and the
+#   StatefulRepository class and will be removed in 2.0.0
+#
+# :nocov:
 class R10K::Git::WorkingDir < R10K::Git::Repository
 
   include R10K::Logging
@@ -40,8 +52,8 @@ class R10K::Git::WorkingDir < R10K::Git::Repository
     @full_path = File.join(@basedir, @dirname)
     @git_dir   = File.join(@full_path, '.git')
 
-    @alternates = R10K::Git::Alternates.new(@git_dir)
-    @cache      = R10K::Git::Cache.generate(@remote)
+    @alternates = R10K::Git::Alternates.new(Pathname.new(@git_dir))
+    @cache      = R10K::Git::ShellGit::Cache.generate(@remote)
 
     if ref.is_a? String
       @ref = R10K::Git::Ref.new(ref, self)
@@ -171,3 +183,4 @@ class R10K::Git::WorkingDir < R10K::Git::Repository
     end
   end
 end
+# :nocov:

data/lib/r10k/logging.rb

@@ -1,12 +1,12 @@
 require 'r10k'
+require 'forwardable'
 
 require 'log4r'
 require 'log4r/configurator'
+require 'r10k/logging/terminaloutputter'
 
 module R10K::Logging
 
-  include Log4r
-
   LOG_LEVELS = %w{DEBUG2 DEBUG1 DEBUG INFO NOTICE WARN ERROR FATAL}
 
   def logger_name
@@ -14,59 +14,96 @@ module R10K::Logging
   end
 
   def logger
-    unless @logger
-      @logger = Log4r::Logger.new(self.logger_name)
-      @logger.add R10K::Logging.outputter
+    if @logger.nil?
+      name = logger_name
+      if Log4r::Logger[name]
+        @logger = Log4r::Logger[name]
+      else
+        @logger = Log4r::Logger.new(name)
+        @logger.add(R10K::Logging.outputter)
+      end
     end
     @logger
   end
 
   class << self
-    include Log4r
 
-    def levels
-      @levels ||= LOG_LEVELS.each.inject({}) do |levels, k|
-        levels[k] = Log4r.const_get(k)
-        levels
+    # Convert the input to a valid Log4r log level
+    #
+    # @param input [String, TrueClass] The level to parse. If TrueClass then
+    #   Log4r::INFO will be returned (indicating a generic raised verbosity),
+    #   if a string it will be parsed either as a numeric value or a textual
+    #   log level.
+    # @api private
+    # @return [Integer, NilClass] The numeric log level, or nil if the log
+    #   level is invalid.
+    def parse_level(input)
+      case input
+      when TrueClass
+        Log4r::INFO
+      when /\A\d+\Z/
+        Integer(input)
+      when String
+        const_name = input.upcase
+        if LOG_LEVELS.include?(const_name)
+          begin
+            Log4r.const_get(const_name.to_sym)
+          rescue NameError
+          end
+        end
       end
     end
 
-    def parse_level(val)
-      begin
-        Integer(val)
-      rescue
-        levels[val.upcase]
+    def level=(val)
+      level = parse_level(val)
+      if level.nil?
+        raise ArgumentError, "Invalid log level '#{val}'. Valid levels are #{LOG_LEVELS.map(&:downcase).inspect}"
       end
-    end
+      outputter.level = level
+      @level = level
 
-    def included(klass)
-      unless @log4r_loaded
-        Configurator.custom_levels(*LOG_LEVELS)
-        Logger.global.level = Log4r::ALL
-        @log4r_loaded = true
+      if level < Log4r::INFO
+        outputter.formatter = debug_formatter
+      else
+        outputter.formatter = default_formatter
       end
     end
 
-    def level
-      @level || Log4r::WARN # Default level is WARN
-    end
+    extend Forwardable
+    def_delegators :@outputter, :use_color, :use_color=
 
-    def level=(val)
-      level = parse_level val
-      raise "Invalid log level: #{val}" unless level
-      outputter.level = level
-      @level = level
+    # @!attribute [r] level
+    #   @return [Integer] The current log level. Lower numbers correspond
+    #     to more verbose log levels.
+    attr_reader :level
+
+    # @!attribute [r] formatter
+    #   @api private
+    #   @return [Log4r::Formatter]
+    attr_reader :formatter
+
+    # @!attribute [r] outputter
+    #   @api private
+    #   @return [Log4r::Outputter]
+    attr_reader :outputter
+
+    def default_formatter
+      Log4r::PatternFormatter.new(:pattern => '%l\t -> %m')
     end
 
-    def formatter
-      @formatter ||= Log4r::PatternFormatter.new(:pattern => '[%C - %l] %m')
+    def debug_formatter
+      Log4r::PatternFormatter.new(:pattern => '[%d - %l] %m')
     end
 
-    def outputter
-      @outputter ||= Log4r::StderrOutputter.new('console',
-        :level => self.level,
-        :formatter => formatter
-       )
+    def default_outputter
+      R10K::Logging::TerminalOutputter.new('terminal', $stderr, :level => self.level, :formatter => formatter)
     end
   end
+
+  Log4r::Configurator.custom_levels(*LOG_LEVELS)
+  Log4r::Logger.global.level = Log4r::ALL
+
+  @level     = Log4r::WARN
+  @formatter = default_formatter
+  @outputter = default_outputter
 end

data/lib/r10k/logging/terminaloutputter.rb

@@ -0,0 +1,36 @@
+require 'colored'
+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