r10k 1.1.4 → 1.2.0rc1

data/lib/r10k/execution.rb

@@ -13,6 +13,7 @@ module Execution
   # @params [Hash] opts
   #
   # @option opts [String] :event An optional log event name. Defaults to cmd.
+  # @option opts [String] :cwd The working directory to use when executing the command
   #
   # @raise [R10K::ExecutionFailure] If the executed command exited with a
   #   nonzero exit code.
@@ -20,11 +21,13 @@ module Execution
   # @return [String] the stdout from the command
   def execute(cmd, opts = {})
 
-    event = opts[:event] || cmd
+    logger.warn "R10K::Execution#execute is deprecated, use R10K::Util::Subprocess"
+
+    event = (opts.delete(:event) || cmd)
 
     logger.debug1 "Execute: #{event.inspect}"
 
-    status, stdout, stderr = systemu(cmd)
+    status, stdout, stderr = systemu(cmd, opts)
 
     logger.debug2 "[#{event}] STDOUT: #{stdout.chomp}" unless stdout.empty?
     logger.debug2 "[#{event}] STDERR: #{stderr.chomp}" unless stderr.empty?

data/lib/r10k/git/cache.rb

@@ -1,15 +1,15 @@
 require 'r10k/logging'
+
+require 'r10k/git'
 require 'r10k/git/repository'
 
 require 'r10k/settings'
 require 'r10k/registry'
 
-module R10K
-module Git
-class Cache < R10K::Git::Repository
-  # Mirror a git repository for use shared git object repositories
-  #
-  # @see man git-clone(1)
+# Mirror a git repository for use shared git object repositories
+#
+# @see man git-clone(1)
+class R10K::Git::Cache < R10K::Git::Repository
 
   include R10K::Settings::Mixin
 
@@ -25,28 +25,24 @@ class Cache < R10K::Git::Repository
 
   include R10K::Logging
 
-  # @!attribute [r] remote
-  #   @return [String] The git repository remote
-  attr_reader :remote
-
   # @!attribute [r] path
+  #   @deprecated
   #   @return [String] The path to the git cache repository
-  attr_reader :path
+  def path
+    logger.warn "#{self.class}#path is deprecated; use #git_dir"
+    @git_dir
+  end
 
   # @param [String] remote
   # @param [String] cache_root
   def initialize(remote)
     @remote = remote
 
-    @path = File.join(settings[:cache_root], sanitized_dirname)
+    @git_dir = File.join(settings[:cache_root], sanitized_dirname)
   end
 
   def sync
-    if @synced
-      # XXX This gets really spammy. Might be good to turn it on later, but for
-      # general work it's way much.
-      #logger.debug "#{@remote} already synced this run, not syncing again"
-    else
+    if not @synced
       sync!
       @synced = true
     end
@@ -54,41 +50,35 @@ class Cache < R10K::Git::Repository
 
   def sync!
     if cached?
-      # XXX This gets really spammy. Might be good to turn it on later, but for
-      # general work it's way much.
-      #logger.debug "Updating existing cache at #{@path}"
-      git "fetch --prune", :git_dir => @path
+      fetch
     else
       logger.debug "Creating new git cache for #{@remote.inspect}"
 
+      # TODO extract this to an initialization step
       unless File.exist? settings[:cache_root]
         FileUtils.mkdir_p settings[:cache_root]
       end
 
-      git "clone --mirror #{@remote} #{@path}"
+      git ['clone', '--mirror', @remote, git_dir]
+    end
+  rescue R10K::Util::Subprocess::SubprocessError => e
+    msg = e.result.stderr.slice(/^fatal: .*$/)
+    if msg
+      raise R10K::Git::GitError, "Couldn't update git cache for #{@remote}: #{msg.inspect}"
+    else
+      raise e
     end
   end
 
   # @return [Array<String>] A list the branches for the git repository
   def branches
-    output = git "branch", :git_dir => @path
-    output.split("\n").map do |str|
-      # the `git branch` command returns output like this:
-      # <pre>
-      #   0.11.x
-      #   0.12.x
-      # * master
-      #   passenger_scoping
-      # </pre>
-      #
-      # The string index notation strips off the leading whitespace/asterisk
-      str[2..-1]
-    end
+    output = git %w[for-each-ref refs/heads --format %(refname)], :git_dir => git_dir
+    output.scan(%r[refs/heads/(.*)$]).flatten
   end
 
   # @return [true, false] If the repository has been locally cached
   def cached?
-    File.exist? @path
+    File.exist? git_dir
   end
 
   private
@@ -97,10 +87,4 @@ class Cache < R10K::Git::Repository
   def sanitized_dirname
     @remote.gsub(/[^@\w\.-]/, '-')
   end
-
-  def git_dir
-    @path
-  end
-end
-end
 end

data/lib/r10k/git/commit.rb

@@ -0,0 +1,22 @@
+require 'r10k/git/ref'
+require 'r10k/git/repository'
+
+# commit: A 40-byte hex representation of a SHA1 referencing a specific commit
+# @see https://www.kernel.org/pub/software/scm/git/docs/gitglossary.html
+# @api private
+class R10K::Git::Commit < R10K::Git::Ref
+
+  # @!attribute [r] commit
+  #   @return [String] The git commit
+  attr_reader :commit
+  alias :ref :commit
+
+  def initialize(commit, repository = nil)
+    @commit = commit
+    @repository = repository
+  end
+
+  def fetch?
+    ! resolvable?
+  end
+end

data/lib/r10k/git/errors.rb

@@ -1,34 +1,43 @@
+require 'r10k/errors'
+
 module R10K
-module Git
-  class NonexistentHashError < StandardError
-    # Raised when a hash was requested that can't be found in the repository
+  module Git
 
-    attr_reader :hash
-    attr_reader :git_dir
+    class GitError < R10KError
+    end
 
-    def initialize(msg = nil, git_dir = nil)
-      super(msg)
+    class UnresolvableRefError < GitError
 
-      @git_dir = git_dir
-    end
+      attr_reader :ref
+      attr_reader :git_dir
 
-    HASHLIKE = %r[[A-Fa-f0-9]]
+      def initialize(*args)
+        super
 
-    # Print a friendly error message if an object hash is given as the message
-    def message
-      msg = super
-      if msg and msg.match(HASHLIKE)
-        msg = "Could not locate hash #{msg.inspect} in repository"
-      elsif msg.nil?
-        msg = "Could not locate hash in repository"
+        @hash    = @options[:ref]
+        @git_dir = @options[:git_dir]
       end
 
-      if @git_dir
-        msg << " at #{@git_dir}. (Does the remote repository need to be updated?)"
-      end
+      HASHLIKE = %r[[A-Fa-f0-9]]
+
+      # Print a friendly error message if an object hash is given as the message
+      def message
+        if @mesg
+          msg = @mesg
+        else
+          msg = "Could not locate hash"
 
-      msg
+          if @hash
+            msg << " '#{@hash}'"
+          end
+        end
+
+        if @git_dir
+          msg << " at #{@git_dir}"
+        end
+
+        msg
+      end
     end
   end
 end
-end

data/lib/r10k/git/head.rb

@@ -0,0 +1,33 @@
+require 'r10k/git'
+require 'r10k/git/ref'
+require 'r10k/git/repository'
+
+
+# head: A named reference to the commit at the tip of a branch. Heads are
+# stored in a file in $GIT_DIR/refs/heads/ directory. except when using packed
+#
+# @see https://www.kernel.org/pub/software/scm/git/docs/gitglossary.html
+# @api private
+class R10K::Git::Head < R10K::Git::Ref
+
+  # @!attribute [r] head
+  #   @return [String] The git head
+  attr_reader :head
+  alias :ref :head
+
+  def initialize(head, repository = nil)
+    @head = head
+    @repository = repository
+  end
+
+  # def sha1
+  #   TODO ensure that @head is an actual head as opposed to a tag or other
+  #   hooliganism.
+  #end
+
+  # If we are tracking a branch, we should always try to fetch a newer version
+  # of that branch.
+  def fetch?
+    true
+  end
+end

data/lib/r10k/git/ref.rb

@@ -0,0 +1,63 @@
+require 'r10k/git'
+require 'r10k/git/repository'
+
+# ref: A 40-byte hex representation of a SHA1 or a name that denotes a
+# particular object. They may be stored in a file under $GIT_DIR/refs/
+# directory, or in the $GIT_DIR/packed-refs file.
+#
+# @see https://www.kernel.org/pub/software/scm/git/docs/gitglossary.html
+# @api private
+class R10K::Git::Ref
+
+  # @!attribute [r] ref
+  #   @return [String] The git reference
+  attr_reader :ref
+
+  # @!attribute [rw] repository
+  #   @return [R10K::Git::Repository] A git repository that can be used to
+  #     resolve the git reference to a commit.
+  attr_accessor :repository
+
+  def initialize(ref, repository = nil)
+    @ref = ref
+    @repository = repository
+  end
+
+  # Can we locate the commit in the related repository?
+  def resolvable?
+    sha1
+    true
+  rescue R10K::Git::UnresolvableRefError
+    false
+  end
+
+  # Should we try to fetch this ref?
+  #
+  # Since we don't know the type of this ref, we have to assume that it might
+  # be a branch and always update accordingly.
+  def fetch?
+    true
+  end
+
+  def sha1
+    if @repository.nil?
+      raise ArgumentError, "Cannot resolve #{self.inspect}: no associated git repository"
+    else
+      @repository.rev_parse(ref)
+    end
+  end
+
+  def ==(other)
+    other.sha1 == self.sha1
+  rescue ArgumentError, R10K::Git::UnresolvableRefError
+    false
+  end
+
+  def to_s
+    ref
+  end
+
+  def inspect
+    "#<#{self.class}: #{to_s}>"
+  end
+end

data/lib/r10k/git/repository.rb

@@ -1,74 +1,103 @@
-require 'r10k/execution'
-require 'r10k/git/errors'
+require 'r10k/git'
+require 'r10k/util/subprocess'
 
-module R10K
-module Git
-class Repository
-  # Define an abstract base class for git repositories.
-
-  include R10K::Execution
+# Define an abstract base class for git repositories.
+class R10K::Git::Repository
 
   # @!attribute [r] remote
   #   @return [String] The URL to the git repository
   attr_reader :remote
 
   # @!attribute [r] basedir
-  #   @return [String] The basedir for the working directory
+  #   @return [String] The directory containing the repository
   attr_reader :basedir
 
   # @!attribute [r] dirname
-  #   @return [String] The name for the directory
+  #   @return [String] The name of the directory
   attr_reader :dirname
 
-  # Resolve a ref to a commit hash
+  # @!attribute [r] git_dir
+  #   Set the path to the git directory. For git repositories with working copies
+  #   this will be `$working_dir/.git`; for bare repositories this will be
+  #   `bare-repo.git`
+  #   @return [String] The path to the git directory
+  attr_reader :git_dir
+
+  # Resolve a ref to a git commit. The given pattern can be a commit, tag,
+  # or a local or remote branch
+  #
+  # @param [String] pattern
   #
-  # @param [String] ref
+  # @return [String] The dereferenced hash of `pattern`
+  def resolve_ref(pattern)
+    commit = nil
+    begin
+      all_commits = git ['show-ref', '-s', pattern], :git_dir => git_dir
+      commit = all_commits.lines.first
+    rescue R10K::Util::Subprocess::SubprocessError
+    end
+
+    if commit.nil?
+      begin
+        commit = git ['rev-parse', "#{ref}^{commit}"], :git_dir => git_dir
+      rescue R10K::Util::Subprocess::SubprocessError
+      end
+    end
+
+    if commit
+      commit.chomp
+    else
+      raise R10K::Git::UnresolvableRefError.new(:ref => pattern, :git_dir => git_dir)
+    end
+  end
+  alias rev_parse resolve_ref
+
+  private
+
+  # Fetch objects and refs from the given git remote
   #
-  # @return [String] The dereferenced hash of `ref`
-  def rev_parse(ref)
-    commit = git "rev-parse #{ref}^{commit}", :git_dir => git_dir
-    commit.chomp
-  rescue R10K::ExecutionFailure
-    raise R10K::Git::NonexistentHashError.new(ref, git_dir)
+  # @param remote [#to_s] The remote name to fetch from
+  def fetch(remote = 'origin')
+    git ['fetch', '--prune', remote], :git_dir => @git_dir
   end
 
   # Wrap git commands
   #
-  # @param [String] command_line_args The arguments for the git prompt
-  # @param [Hash] opts
+  # @param cmd [Array<String>] cmd The arguments for the git prompt
+  # @param opts [Hash] opts
   #
+  # @option opts [String] :path
   # @option opts [String] :git_dir
   # @option opts [String] :work_tree
-  # @option opts [String] :work_tree
   #
   # @raise [R10K::ExecutionFailure] If the executed command exited with a
   #   nonzero exit code.
   #
   # @return [String] The git command output
-  def git(command_line_args, opts = {})
-    args = %w{git}
-
-    log_event = "git #{command_line_args}"
-    log_event << ", args: #{opts.inspect}" unless opts.empty?
-
+  def git(cmd, opts = {})
+    argv = %w{git}
 
     if opts[:path]
-      args << "--git-dir #{opts[:path]}/.git"
-      args << "--work-tree #{opts[:path]}"
+      argv << "--git-dir"   << File.join(opts[:path], '.git')
+      argv << "--work-tree" << opts[:path]
     else
       if opts[:git_dir]
-        args << "--git-dir #{opts[:git_dir]}"
+        argv << "--git-dir" << opts[:git_dir]
       end
       if opts[:work_tree]
-        args << "--work-tree #{opts[:work_tree]}"
+        argv << "--work-tree" << opts[:work_tree]
       end
     end
 
-    args << command_line_args
-    cmd = args.join(' ')
+    argv.concat(cmd)
+
+    subproc = R10K::Util::Subprocess.new(argv)
+    subproc.raise_on_fail = true
+    subproc.logger = self.logger
+
+    result = subproc.execute
 
-    execute(cmd, :event => log_event)
+    # todo ensure that logging always occurs even if the command fails to run
+    result.stdout
   end
 end
-end
-end