git 2.0.0.pre2 → 2.0.0

data/lib/git/errors.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+module Git
+  # Base class for all custom git module errors
+  #
+  # The git gem will only raise an `ArgumentError` or an error that is a subclass of
+  # `Git::Error`. It does not explicitly raise any other types of errors.
+  #
+  # It is recommended to rescue `Git::Error` to catch any runtime error raised by
+  # this gem unless you need more specific error handling.
+  #
+  # Git's custom errors are arranged in the following class heirarchy:
+  #
+  # ```text
+  # StandardError
+  # └─> Git::Error
+  #     ├─> Git::CommandLineError
+  #     │   ├─> Git::FailedError
+  #     │   └─> Git::SignaledError
+  #     │       └─> Git::TimeoutError
+  #     ├─> Git::ProcessIOError
+  #     └─> Git::UnexpectedResultError
+  # ```
+  #
+  # | Error Class | Description |
+  # | --- | --- |
+  # | `Error` | This catch-all error serves as the base class for other custom errors raised by the git gem. |
+  # | `CommandLineError` | A subclass of this error is raised when there is a problem executing the git command line. |
+  # | `FailedError` | This error is raised when the git command line exits with a non-zero status code that is not expected by the git gem. |
+  # | `SignaledError` | This error is raised when the git command line is terminated as a result of receiving a signal. This could happen if the process is forcibly terminated or if there is a serious system error. |
+  # | `TimeoutError` | This is a specific type of `SignaledError` that is raised when the git command line operation times out and is killed via the SIGKILL signal. This happens if the operation takes longer than the timeout duration configured in `Git.config.timeout` or via the `:timeout` parameter given in git methods that support timeouts. |
+  # | `ProcessIOError` | An error was encountered reading or writing to a subprocess. |
+  # | `UnexpectedResultError` | The command line ran without error but did not return the expected results. |
+  #
+  # @example Rescuing a generic error
+  #   begin
+  #     # some git operation
+  #   rescue Git::Error => e
+  #     puts "An error occurred: #{e.message}"
+  #   end
+  #
+  # @example Rescuing a timeout error
+  #   begin
+  #     timeout_duration = 0.001 # seconds
+  #     repo = Git.clone('https://github.com/ruby-git/ruby-git', 'ruby-git-temp', timeout: timeout_duration)
+  #   rescue Git::TimeoutError => e # Catch the more specific error first!
+  #     puts "Git clone took too long and timed out #{e}"
+  #   rescue Git::Error => e
+  #     puts "Received the following error: #{e}"
+  #   end
+  #
+  # @see Git::CommandLineError
+  # @see Git::FailedError
+  # @see Git::SignaledError
+  # @see Git::TimeoutError
+  # @see Git::ProcessIOError
+  # @see Git::UnexpectedResultError
+  #
+  # @api public
+  #
+  class Error < StandardError; end
+
+  # An alias for Git::Error
+  #
+  # Git::GitExecuteError error class is an alias for Git::Error for backwards
+  # compatibility. It is recommended to use Git::Error directly.
+  #
+  # @deprecated Use Git::Error instead
+  #
+  GitExecuteError = ActiveSupport::Deprecation::DeprecatedConstantProxy.new('Git::GitExecuteError', 'Git::Error', Git::Deprecation)
+
+  # Raised when a git command fails or exits because of an uncaught signal
+  #
+  # The git command executed, status, stdout, and stderr are available from this
+  # object.
+  #
+  # The Gem will raise a more specific error for each type of failure:
+  #
+  # * {Git::FailedError}: when the git command exits with a non-zero status
+  # * {Git::SignaledError}: when the git command exits because of an uncaught signal
+  # * {Git::TimeoutError}: when the git command times out
+  #
+  # @api public
+  #
+  class CommandLineError < Git::Error
+    # Create a CommandLineError object
+    #
+    # @example
+    #   `exit 1` # set $? appropriately for this example
+    #   result = Git::CommandLineResult.new(%w[git status], $?, 'stdout', 'stderr')
+    #   error = Git::CommandLineError.new(result)
+    #   error.to_s #=> '["git", "status"], status: pid 89784 exit 1, stderr: "stderr"'
+    #
+    # @param result [Git::CommandLineResult] the result of the git command including
+    #   the git command, status, stdout, and stderr
+    #
+    def initialize(result)
+      @result = result
+      super(error_message)
+    end
+
+    # The human readable representation of this error
+    #
+    # @example
+    #   error.error_message #=> '["git", "status"], status: pid 89784 exit 1, stderr: "stderr"'
+    #
+    # @return [String]
+    #
+    def error_message = <<~MESSAGE.chomp
+      #{result.git_cmd}, status: #{result.status}, stderr: #{result.stderr.inspect}
+    MESSAGE
+
+    # @attribute [r] result
+    #
+    # The result of the git command including the git command and its status and output
+    #
+    # @example
+    #   error.result #=> #<Git::CommandLineResult:0x00000001046bd488 ...>
+    #
+    # @return [Git::CommandLineResult]
+    #
+    attr_reader :result
+  end
+
+  # This error is raised when a git command returns a non-zero exitstatus
+  #
+  # The git command executed, status, stdout, and stderr are available from this
+  # object.
+  #
+  # @api public
+  #
+  class FailedError < Git::CommandLineError; end
+
+  # This error is raised when a git command exits because of an uncaught signal
+  #
+  # @api public
+  #
+  class SignaledError < Git::CommandLineError; end
+
+  # This error is raised when a git command takes longer than the configured timeout
+  #
+  # The git command executed, status, stdout, and stderr, and the timeout duration
+  # are available from this object.
+  #
+  # result.status.timeout? will be `true`
+  #
+  # @api public
+  #
+  class TimeoutError < Git::SignaledError
+    # Create a TimeoutError object
+    #
+    # @example
+    #   command = %w[sleep 10]
+    #   timeout_duration = 1
+    #   status = ProcessExecuter.spawn(*command, timeout: timeout_duration)
+    #   result = Git::CommandLineResult.new(command, status, 'stdout', 'err output')
+    #   error = Git::TimeoutError.new(result, timeout_duration)
+    #   error.error_message #=> '["sleep", "10"], status: pid 70144 SIGKILL (signal 9), stderr: "err output", timed out after 1s'
+    #
+    # @param result [Git::CommandLineResult] the result of the git command including
+    #   the git command, status, stdout, and stderr
+    #
+    # @param timeout_duration [Numeric] the amount of time the subprocess was allowed
+    #   to run before being killed
+    #
+    def initialize(result, timeout_duration)
+      @timeout_duration = timeout_duration
+      super(result)
+    end
+
+    # The human readable representation of this error
+    #
+    # @example
+    #   error.error_message #=> '["sleep", "10"], status: pid 88811 SIGKILL (signal 9), stderr: "err output", timed out after 1s'
+    #
+    # @return [String]
+    #
+    def error_message = <<~MESSAGE.chomp
+      #{super}, timed out after #{timeout_duration}s
+    MESSAGE
+
+    # The amount of time the subprocess was allowed to run before being killed
+    #
+    # @example
+    #   `kill -9 $$` # set $? appropriately for this example
+    #   result = Git::CommandLineResult.new(%w[git status], $?, '', "killed")
+    #   error = Git::TimeoutError.new(result, 10)
+    #   error.timeout_duration #=> 10
+    #
+    # @return [Numeric]
+    #
+    attr_reader :timeout_duration
+  end
+
+  # Raised when the output of a git command can not be read
+  #
+  # @api public
+  #
+  class ProcessIOError < Git::Error; end
+
+  # Raised when the git command result was not as expected
+  #
+  # @api public
+  #
+  class UnexpectedResultError < Git::Error; end
+end

data/lib/git/lib.rb

@@ -1,5 +1,5 @@
-require 'git/failed_error'
 require 'git/command_line'
+require 'git/errors'
 require 'logger'
 require 'pp'
 require 'process_executer'
@@ -80,22 +80,34 @@ module Git
       command('init', *arr_opts)
     end
 
-    # tries to clone the given repo
+    # Clones a repository into a newly created directory
     #
-    # accepts options:
-    #  :bare::      no working directory
-    #  :branch::    name of branch to track (rather than 'master')
-    #  :depth::     the number of commits back to pull
-    #  :filter::    specify partial clone
-    #  :origin::    name of remote (same as remote)
-    #  :path::      directory where the repo will be cloned
-    #  :remote::    name of remote (rather than 'origin')
-    #  :recursive:: after the clone is created, initialize all submodules within, using their default settings.
+    # @param [String] repository_url the URL of the repository to clone
+    # @param [String, nil] directory the directory to clone into
+    #
+    #   If nil, the repository is cloned into a directory with the same name as
+    #   the repository.
+    #
+    # @param [Hash] opts the options for this command
     #
-    # TODO - make this work with SSH password or auth_key
+    # @option opts [Boolean] :bare (false) if true, clone as a bare repository
+    # @option opts [String] :branch the branch to checkout
+    # @option opts [String, Array] :config one or more configuration options to set
+    # @option opts [Integer] :depth the number of commits back to pull
+    # @option opts [String] :filter specify partial clone
+    # @option opts [String] :mirror set up a mirror of the source repository
+    # @option opts [String] :origin the name of the remote
+    # @option opts [String] :path an optional prefix for the directory parameter
+    # @option opts [String] :remote the name of the remote
+    # @option opts [Boolean] :recursive after the clone is created, initialize all submodules within, using their default settings
+    # @option opts [Numeric, nil] :timeout the number of seconds to wait for the command to complete
+    #
+    #   See {Git::Lib#command} for more information about :timeout
     #
     # @return [Hash] the options to pass to {Git::Base.new}
     #
+    # @todo make this work with SSH password or auth_key
+    #
     def clone(repository_url, directory, opts = {})
       @path = opts[:path] || '.'
       clone_dir = opts[:path] ? File.join(@path, directory) : directory
@@ -143,7 +155,7 @@ module Git
       match_data = output.match(%r{^ref: refs/heads/(?<default_branch>[^\t]+)\tHEAD$})
       return match_data[:default_branch] if match_data
 
-      raise 'Unable to determine the default branch'
+      raise Git::UnexpectedResultError, 'Unable to determine the default branch'
     end
 
     ## READ COMMANDS ##
@@ -408,7 +420,7 @@ module Git
     def branches_all
       command_lines('branch', '-a').map do |line|
         match_data = line.match(BRANCH_LINE_REGEXP)
-        raise GitExecuteError, 'Unexpected branch line format' unless match_data
+        raise Git::UnexpectedResultError, 'Unexpected branch line format' unless match_data
         next nil if match_data[:not_a_branch] || match_data[:detached_ref]
         [
           match_data[:refname],
@@ -933,7 +945,7 @@ module Git
       opts = opts.last.instance_of?(Hash) ? opts.last : {}
 
       if (opts[:a] || opts[:annotate]) && !(opts[:m] || opts[:message])
-        raise  "Can not create an [:a|:annotate] tag without the precense of [:m|:message]."
+        raise  ArgumentError, 'Cannot create an annotated tag without a message.'
       end
 
       arr_opts = []
@@ -1006,10 +1018,11 @@ module Git
       end
     end
 
-    def pull(remote = nil, branch = nil)
+    def pull(remote = nil, branch = nil, opts = {})
       raise ArgumentError, "You must specify a remote if a branch is specified" if remote.nil? && !branch.nil?
 
       arr_opts = []
+      arr_opts << '--allow-unrelated-histories' if opts[:allow_unrelated_histories]
       arr_opts << remote if remote
       arr_opts << branch if branch
       command('pull', *arr_opts)
@@ -1214,15 +1227,25 @@ module Git
     #
     # @param chdir [String, nil] the directory to run the command in
     #
-    # @param timeout [Numeric, nil] the maximum time to wait for the command to
-    # complete
+    # @param timeout [Numeric, nil] the maximum seconds to wait for the command to complete
+    #
+    #   If timeout is nil, the global timeout from {Git::Config} is used.
+    #
+    #   If timeout is zero, the timeout will not be enforced.
+    #
+    #   If the command times out, it is killed via a `SIGKILL` signal and `Git::TimeoutError` is raised.
+    #
+    #   If the command does not respond to SIGKILL, it will hang this method.
     #
     # @see Git::CommandLine#run
     #
     # @return [String] the command's stdout (or merged stdout and stderr if `merge`
     # is true)
     #
-    # @raise [Git::GitExecuteError] if the command fails
+    # @raise [Git::FailedError] if the command failed
+    # @raise [Git::SignaledError] if the command was signaled
+    # @raise [Git::TimeoutError] if the command times out
+    # @raise [Git::ProcessIOError] if an exception was raised while collecting subprocess output
     #
     #   The exception's `result` attribute is a {Git::CommandLineResult} which will
     #   contain the result of the command including the exit status, stdout, and

data/lib/git/object.rb

@@ -1,16 +1,18 @@
+require 'git/author'
+require 'git/diff'
+require 'git/errors'
+require 'git/log'
+
 module Git
-  
-  class GitTagNameDoesNotExist< StandardError 
-  end
-  
+
   # represents a git object
   class Object
-    
+
     class AbstractObject
       attr_accessor :objectish, :type, :mode
 
       attr_writer :size
-      
+
       def initialize(base, objectish)
         @base = base
         @objectish = objectish.to_s
@@ -23,11 +25,11 @@ module Git
       def sha
         @sha ||= @base.lib.revparse(@objectish)
       end
-      
+
       def size
         @size ||= @base.lib.object_size(@objectish)
       end
-      
+
       # Get the object's contents.
       # If no block is given, the contents are cached in memory and returned as a string.
       # If a block is given, it yields an IO object (via IO::popen) which could be used to
@@ -41,108 +43,108 @@ module Git
           @contents ||= @base.lib.object_contents(@objectish)
         end
       end
-      
+
       def contents_array
         self.contents.split("\n")
       end
-      
+
       def to_s
         @objectish
       end
-      
+
       def grep(string, path_limiter = nil, opts = {})
         opts = {:object => sha, :path_limiter => path_limiter}.merge(opts)
         @base.lib.grep(string, opts)
       end
-      
+
       def diff(objectish)
         Git::Diff.new(@base, @objectish, objectish)
       end
-      
+
       def log(count = 30)
         Git::Log.new(@base, count).object(@objectish)
       end
-      
+
       # creates an archive of this object (tree)
       def archive(file = nil, opts = {})
         @base.lib.archive(@objectish, file, opts)
       end
-      
+
       def tree?; false; end
-      
+
       def blob?; false; end
-      
+
       def commit?; false; end
 
       def tag?; false; end
-     
+
     end
-  
-    
+
+
     class Blob < AbstractObject
-      
+
       def initialize(base, sha, mode = nil)
         super(base, sha)
         @mode = mode
       end
-      
+
       def blob?
         true
       end
 
     end
-  
+
     class Tree < AbstractObject
-      
+
       def initialize(base, sha, mode = nil)
         super(base, sha)
         @mode = mode
         @trees = nil
         @blobs = nil
       end
-            
+
       def children
         blobs.merge(subtrees)
       end
-      
+
       def blobs
         @blobs ||= check_tree[:blobs]
       end
       alias_method :files, :blobs
-      
+
       def trees
         @trees ||= check_tree[:trees]
       end
       alias_method :subtrees, :trees
       alias_method :subdirectories, :trees
-       
+
       def full_tree
         @base.lib.full_tree(@objectish)
       end
-                  
+
       def depth
         @base.lib.tree_depth(@objectish)
       end
-      
+
       def tree?
         true
       end
-       
+
       private
 
         # actually run the git command
         def check_tree
           @trees = {}
           @blobs = {}
-          
+
           data = @base.lib.ls_tree(@objectish)
 
-          data['tree'].each do |key, tree| 
-            @trees[key] = Git::Object::Tree.new(@base, tree[:sha], tree[:mode]) 
+          data['tree'].each do |key, tree|
+            @trees[key] = Git::Object::Tree.new(@base, tree[:sha], tree[:mode])
           end
-          
-          data['blob'].each do |key, blob| 
-            @blobs[key] = Git::Object::Blob.new(@base, blob[:sha], blob[:mode]) 
+
+          data['blob'].each do |key, blob|
+            @blobs[key] = Git::Object::Blob.new(@base, blob[:sha], blob[:mode])
           end
 
           {
@@ -150,11 +152,11 @@ module Git
             :blobs => @blobs
           }
         end
-      
+
     end
-  
+
     class Commit < AbstractObject
-      
+
       def initialize(base, sha, init = nil)
         super(base, sha)
         @tree = nil
@@ -166,48 +168,48 @@ module Git
           set_commit(init)
         end
       end
-      
+
       def message
         check_commit
         @message
       end
-      
+
       def name
         @base.lib.namerev(sha)
       end
-      
+
       def gtree
         check_commit
         Tree.new(@base, @tree)
       end
-      
+
       def parent
         parents.first
       end
-      
+
       # array of all parent commits
       def parents
         check_commit
-        @parents        
+        @parents
       end
-      
+
       # git author
-      def author     
+      def author
         check_commit
         @author
       end
-      
+
       def author_date
         author.date
       end
-      
+
       # git author
       def committer
         check_commit
         @committer
       end
-      
-      def committer_date 
+
+      def committer_date
         committer.date
       end
       alias_method :date, :committer_date
@@ -215,7 +217,7 @@ module Git
       def diff_parent
         diff(parent)
       end
-      
+
       def set_commit(data)
         @sha ||= data['sha']
         @committer = Git::Author.new(data['committer'])
@@ -224,26 +226,26 @@ module Git
         @parents = data['parent'].map{ |sha| Git::Object::Commit.new(@base, sha) }
         @message = data['message'].chomp
       end
-      
+
       def commit?
         true
       end
 
       private
-  
+
         # see if this object has been initialized and do so if not
         def check_commit
           return if @tree
-          
+
           data = @base.lib.commit_data(@objectish)
           set_commit(data)
         end
-      
+
     end
-  
+
     class Tag < AbstractObject
       attr_accessor :name
-      
+
       def initialize(base, sha, name)
         super(base, sha)
         @name = name
@@ -259,7 +261,7 @@ module Git
         check_tag()
         return @message
       end
-      
+
       def tag?
         true
       end
@@ -274,7 +276,7 @@ module Git
       def check_tag
         return if @loaded
 
-        if !self.annotated? 
+        if !self.annotated?
           @message = @tagger = nil
         else
           tdata = @base.lib.tag_data(@name)
@@ -284,29 +286,29 @@ module Git
 
         @loaded = true
       end
-        
+
     end
-    
+
     # if we're calling this, we don't know what type it is yet
     # so this is our little factory method
     def self.new(base, objectish, type = nil, is_tag = false)
       if is_tag
         sha = base.lib.tag_sha(objectish)
         if sha == ''
-          raise Git::GitTagNameDoesNotExist.new(objectish)
+          raise Git::UnexpectedResultError.new("Tag '#{objectish}' does not exist.")
         end
         return Git::Object::Tag.new(base, sha, objectish)
       end
-      
+
       type ||= base.lib.object_type(objectish)
       klass =
         case type
-        when /blob/   then Blob   
+        when /blob/   then Blob
         when /commit/ then Commit
         when /tree/   then Tree
         end
       klass.new(base, objectish)
     end
-    
+
   end
 end

data/lib/git/version.rb

@@ -1,5 +1,5 @@
 module Git
   # The current gem version
   # @return [String] the current gem version.
-  VERSION='2.0.0.pre2'
+  VERSION='2.0.0'
 end