rugged 0.24.6.1 → 0.25.0

data/lib/rugged/remote.rb

@@ -1,3 +1,8 @@
+# Copyright (C) the Rugged contributors.  All rights reserved.
+#
+# This file is part of Rugged, distributed under the MIT license.
+# For full terms see the included LICENSE file.
+
 module Rugged
   class Remote
   end

data/lib/rugged/repository.rb

@@ -1,3 +1,8 @@
+# Copyright (C) the Rugged contributors.  All rights reserved.
+#
+# This file is part of Rugged, distributed under the MIT license.
+# For full terms see the included LICENSE file.
+
 module Rugged
   # Repository is an interface into a Git repository on-disk. It's the primary
   # interface between your app and the main Git objects Rugged makes available
@@ -140,7 +145,7 @@ module Rugged
 
     # All the tags in the repository.
     #
-    # Returns an TagCollection containing all the tags.
+    # Returns a TagCollection containing all the tags.
     def tags
       @tags ||= TagCollection.new(self)
     end
@@ -155,14 +160,14 @@ module Rugged
 
     # All the branches in the repository
     #
-    # Returns an BranchCollection containing Rugged::Branch objects
+    # Returns a BranchCollection containing Rugged::Branch objects
     def branches
       @branches ||= BranchCollection.new(self)
     end
 
     # All the submodules in the repository
     #
-    # Returns an SubmoduleCollection containing Rugged::Submodule objects
+    # Returns a SubmoduleCollection containing Rugged::Submodule objects
     def submodules
       @submodules ||= SubmoduleCollection.new(self)
     end
@@ -190,7 +195,7 @@ module Rugged
     # revision - The String SHA1.
     # path     - The String file path.
     #
-    # Returns a String.
+    # Returns a Rugged::Blob object
     def blob_at(revision, path)
       tree = Rugged::Commit.lookup(self, revision).tree
       begin

data/lib/rugged/submodule_collection.rb

@@ -1,3 +1,8 @@
+# Copyright (C) the Rugged contributors.  All rights reserved.
+#
+# This file is part of Rugged, distributed under the MIT license.
+# For full terms see the included LICENSE file.
+
 module Rugged
   class SubmoduleCollection
 

data/lib/rugged/tag.rb

@@ -1,3 +1,8 @@
+# Copyright (C) the Rugged contributors.  All rights reserved.
+#
+# This file is part of Rugged, distributed under the MIT license.
+# For full terms see the included LICENSE file.
+
 module Rugged
   class Tag < Rugged::Reference
     GPG_SIGNATURE_PREFIX = "-----BEGIN PGP SIGNATURE-----".freeze

data/lib/rugged/tree.rb

@@ -1,5 +1,160 @@
+# Copyright (C) the Rugged contributors.  All rights reserved.
+#
+# This file is part of Rugged, distributed under the MIT license.
+# For full terms see the included LICENSE file.
+
 module Rugged
   class Tree
+    ##
+    # call-seq:
+    #   Tree.diff(repo, tree, diffable[, options]) -> diff
+    #
+    # Returns a diff between the `tree` and the diffable object that was given.
+    # +diffable+ can either be a +Rugged::Commit+, a +Rugged::Tree+, a +Rugged::Index+,
+    # or +nil+.
+    #
+    # The +tree+ object will be used as the "old file" side of the diff, while the
+    # parent tree or the +diffable+ object will be used for the "new file" side.
+    #
+    # If +tree+ or +diffable+ are nil, they will be treated as an empty tree. Passing
+    # both as `nil` will raise an exception.
+    #
+    # The following options can be passed in the +options+ Hash:
+    #
+    # :paths ::
+    #   An array of paths / fnmatch patterns to constrain the diff to a specific
+    #   set of files. Also see +:disable_pathspec_match+.
+    #
+    # :max_size ::
+    #   An integer specifying the maximum byte size of a file before a it will
+    #   be treated as binary. The default value is 512MB.
+    #
+    # :context_lines ::
+    #   The number of unchanged lines that define the boundary of a hunk (and
+    #   to display before and after the actual changes). The default is 3.
+    #
+    # :interhunk_lines ::
+    #   The maximum number of unchanged lines between hunk boundaries before the hunks
+    #   will be merged into a one. The default is 0.
+    #
+    # :old_prefix ::
+    #   The virtual "directory" to prefix to old filenames in hunk headers.
+    #   The default is "a".
+    #
+    # :new_prefix ::
+    #   The virtual "directory" to prefix to new filenames in hunk headers.
+    #   The default is "b".
+    #
+    # :reverse ::
+    #   If true, the sides of the diff will be reversed.
+    #
+    # :force_text ::
+    #   If true, all files will be treated as text, disabling binary attributes & detection.
+    #
+    # :ignore_whitespace ::
+    #   If true, all whitespace will be ignored.
+    #
+    # :ignore_whitespace_change ::
+    #   If true, changes in amount of whitespace will be ignored.
+    #
+    # :ignore_whitespace_eol ::
+    #   If true, whitespace at end of line will be ignored.
+    #
+    # :ignore_submodules ::
+    #   if true, submodules will be excluded from the diff completely.
+    #
+    # :patience ::
+    #   If true, the "patience diff" algorithm will be used (currenlty unimplemented).
+    #
+    # :include_ignored ::
+    #   If true, ignored files will be included in the diff.
+    #
+    # :include_untracked ::
+    #  If true, untracked files will be included in the diff.
+    #
+    # :include_unmodified ::
+    #   If true, unmodified files will be included in the diff.
+    #
+    # :recurse_untracked_dirs ::
+    #   Even if +:include_untracked+ is true, untracked directories will only be
+    #   marked with a single entry in the diff. If this flag is set to true,
+    #   all files under ignored directories will be included in the diff, too.
+    #
+    # :disable_pathspec_match ::
+    #   If true, the given +:paths+ will be applied as exact matches, instead of
+    #   as fnmatch patterns.
+    #
+    # :deltas_are_icase ::
+    #   If true, filename comparisons will be made with case-insensitivity.
+    #
+    # :include_untracked_content ::
+    #   if true, untracked content will be contained in the the diff patch text.
+    #
+    # :skip_binary_check ::
+    #   If true, diff deltas will be generated without spending time on binary
+    #   detection. This is useful to improve performance in cases where the actual
+    #   file content difference is not needed.
+    #
+    # :include_typechange ::
+    #   If true, type changes for files will not be interpreted as deletion of
+    #   the "old file" and addition of the "new file", but will generate
+    #   typechange records.
+    #
+    # :include_typechange_trees ::
+    #   Even if +:include_typechange+ is true, blob -> tree changes will still
+    #   usually be handled as a deletion of the blob. If this flag is set to true,
+    #   blob -> tree changes will be marked as typechanges.
+    #
+    # :ignore_filemode ::
+    #   If true, file mode changes will be ignored.
+    #
+    # :recurse_ignored_dirs ::
+    #   Even if +:include_ignored+ is true, ignored directories will only be
+    #   marked with a single entry in the diff. If this flag is set to true,
+    #   all files under ignored directories will be included in the diff, too.
+    #
+    # Examples:
+    #
+    #   # Emulating `git diff <treeish>`
+    #   tree = Rugged::Tree.lookup(repo, "d70d245ed97ed2aa596dd1af6536e4bfdb047b69")
+    #   diff = tree.diff(repo.index)
+    #   diff.merge!(tree.diff)
+    #
+    #   # Tree-to-Tree Diff
+    #   tree = Rugged::Tree.lookup(repo, "d70d245ed97ed2aa596dd1af6536e4bfdb047b69")
+    #   other_tree = Rugged::Tree.lookup(repo, "7a9e0b02e63179929fed24f0a3e0f19168114d10")
+    #   diff = tree.diff(other_tree)
+    #
+
+    def self.diff(repo, tree, other_tree = nil, options = {})
+      if tree && !tree.is_a?(Rugged::Tree)
+        raise TypeError, "At least a Rugged::Tree object is required for diffing"
+      end
+
+      if other_tree.nil?
+        if tree.nil?
+          raise TypeError, "Need 'old' or 'new' for diffing"
+        else
+          diff_tree_to_tree repo, tree, nil, options
+        end
+      else
+        if other_tree.is_a?(::String)
+          other_tree = Rugged::Object.rev_parse repo, other_tree
+        end
+
+        case other_tree
+        when Rugged::Commit
+          diff_tree_to_tree repo, tree, other_tree.tree, options
+        when Rugged::Tree
+          diff_tree_to_tree repo, tree, other_tree, options
+        when Rugged::Index
+          diff_tree_to_index repo, tree, other_tree, options
+        else
+          raise TypeError, "A Rugged::Commit, Rugged::Tree or Rugged::Index instance is required"
+        end
+      end
+    end
+
     include Enumerable
 
     attr_reader :owner
@@ -30,7 +185,7 @@ module Rugged
       self.each { |e| yield e if e[:type] == :blob }
     end
 
-    # Iterat over the subtrees in this tree
+    # Iterate over the subtrees in this tree
     def each_tree
       self.each { |e| yield e if e[:type] == :tree }
     end

data/lib/rugged/version.rb

@@ -1,3 +1,8 @@
+# Copyright (C) the Rugged contributors.  All rights reserved.
+#
+# This file is part of Rugged, distributed under the MIT license.
+# For full terms see the included LICENSE file.
+
 module Rugged
-  Version = VERSION = '0.24.6.1'
+  Version = VERSION = '0.25.0'
 end

data/lib/rugged/walker.rb

@@ -1,3 +1,8 @@
+# Copyright (C) the Rugged contributors.  All rights reserved.
+#
+# This file is part of Rugged, distributed under the MIT license.
+# For full terms see the included LICENSE file.
+
 module Rugged
   class Walker
     include Enumerable

data/lib/rugged.rb

@@ -1,3 +1,8 @@
+# Copyright (C) the Rugged contributors.  All rights reserved.
+#
+# This file is part of Rugged, distributed under the MIT license.
+# For full terms see the included LICENSE file.
+
 begin
   RUBY_VERSION =~ /(\d+.\d+)/
   require "rugged/#{$1}/rugged"

data/vendor/libgit2/CMakeLists.txt

@@ -20,6 +20,7 @@ SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Mo
 
 INCLUDE(CheckLibraryExists)
 INCLUDE(CheckFunctionExists)
+INCLUDE(CheckSymbolExists)
 INCLUDE(CheckStructHasMember)
 INCLUDE(AddCFlagIfSupported)
 INCLUDE(FindPkgConfig)
@@ -109,7 +110,7 @@ ELSE ()
 ENDIF()
 
 IF (HAVE_STRUCT_STAT_NSEC OR WIN32)
-	OPTION( USE_NSEC		"Care about sub-second file mtimes and ctimes"	OFF )
+	OPTION( USE_NSEC		"Care about sub-second file mtimes and ctimes"	ON  )
 ENDIF()
 
 # This variable will contain the libraries we need to put into
@@ -507,6 +508,11 @@ ELSE ()
 	ENDIF ()
 ENDIF()
 
+CHECK_SYMBOL_EXISTS(regcomp_l "regex.h;xlocale.h" HAVE_REGCOMP_L)
+IF (HAVE_REGCOMP_L)
+	ADD_DEFINITIONS(-DHAVE_REGCOMP_L)
+ENDIF ()
+
 CHECK_FUNCTION_EXISTS(futimens HAVE_FUTIMENS)
 IF (HAVE_FUTIMENS)
 	ADD_DEFINITIONS(-DHAVE_FUTIMENS)
@@ -589,8 +595,10 @@ IF (CMAKE_SIZEOF_VOID_P EQUAL 8)
 	ADD_DEFINITIONS(-DGIT_ARCH_64)
 ELSEIF (CMAKE_SIZEOF_VOID_P EQUAL 4)
 	ADD_DEFINITIONS(-DGIT_ARCH_32)
+ELSEIF (CMAKE_SIZEOF_VOID_P)
+	MESSAGE(FATAL_ERROR "Unsupported architecture (pointer size is ${CMAKE_SIZEOF_VOID_P} bytes)")
 ELSE()
-	MESSAGE(FATAL_ERROR "Unsupported architecture")
+	MESSAGE(FATAL_ERROR "Unsupported architecture (CMAKE_SIZEOF_VOID_P is unset)")
 ENDIF()
 
 # Compile and link libgit2
@@ -697,6 +705,8 @@ IF (BUILD_CLAR)
 	# Add a test target which runs the cred callback tests, to be
 	# called after setting the url and user
 	ADD_TEST(libgit2_clar-cred_callback libgit2_clar -v -sonline::clone::cred_callback)
+	ADD_TEST(libgit2_clar-proxy_credentials_in_url libgit2_clar -v -sonline::clone::proxy_credentials_in_url)
+	ADD_TEST(libgit2_clar-proxy_credentials_request libgit2_clar -v	-sonline::clone::proxy_credentials_request)
 ENDIF ()
 
 IF (TAGS)

data/vendor/libgit2/include/git2/blob.h

@@ -150,46 +150,48 @@ GIT_EXTERN(int) git_blob_create_fromworkdir(git_oid *id, git_repository *repo, c
  */
 GIT_EXTERN(int) git_blob_create_fromdisk(git_oid *id, git_repository *repo, const char *path);
 
-
-typedef int (*git_blob_chunk_cb)(char *content, size_t max_length, void *payload);
-
 /**
- * Write a loose blob to the Object Database from a
- * provider of chunks of data.
+ * Create a stream to write a new blob into the object db
+ *
+ * This function may need to buffer the data on disk and will in
+ * general not be the right choice if you know the size of the data
+ * to write. If you have data in memory, use
+ * `git_blob_create_frombuffer()`. If you do not, but know the size of
+ * the contents (and don't want/need to perform filtering), use
+ * `git_odb_open_wstream()`.
+ *
+ * Don't close this stream yourself but pass it to
+ * `git_blob_create_fromstream_commit()` to commit the write to the
+ * object db and get the object id.
  *
  * If the `hintpath` parameter is filled, it will be used to determine
  * what git filters should be applied to the object before it is written
  * to the object database.
  *
- * The implementation of the callback MUST respect the following rules:
- *
- *  - `content` must be filled by the callback. The maximum number of
- *    bytes that the buffer can accept per call is defined by the
- *    `max_length` parameter. Allocation and freeing of the buffer will
- *    be taken care of by libgit2.
- *
- *  - The `callback` must return the number of bytes that have been
- *    written to the `content` buffer.
- *
- *  - When there is no more data to stream, `callback` should return 0.
- *    This will prevent it from being invoked anymore.
- *
- *  - If an error occurs, the callback should return a negative value.
- *    This value will be returned to the caller.
- *
- * @param id Return the id of the written blob
+ * @param out the stream into which to write
  * @param repo Repository where the blob will be written.
  *        This repository can be bare or not.
  * @param hintpath If not NULL, will be used to select data filters
  *        to apply onto the content of the blob to be created.
- * @return 0 or error code (from either libgit2 or callback function)
+ * @return 0 or error code
  */
-GIT_EXTERN(int) git_blob_create_fromchunks(
-	git_oid *id,
+GIT_EXTERN(int) git_blob_create_fromstream(
+	git_writestream **out,
 	git_repository *repo,
-	const char *hintpath,
-	git_blob_chunk_cb callback,
-	void *payload);
+	const char *hintpath);
+
+/**
+ * Close the stream and write the blob to the object db
+ *
+ * The stream will be closed and freed.
+ *
+ * @param out the id of the new blob
+ * @param stream the stream to close
+ * @return 0 or an error code
+ */
+GIT_EXTERN(int) git_blob_create_fromstream_commit(
+	git_oid *out,
+	git_writestream *stream);
 
 /**
  * Write an in-memory buffer to the ODB as a blob
@@ -216,6 +218,15 @@ GIT_EXTERN(int) git_blob_create_frombuffer(
  */
 GIT_EXTERN(int) git_blob_is_binary(const git_blob *blob);
 
+/**
+ * Create an in-memory copy of a blob. The copy must be explicitly
+ * free'd or it will leak.
+ *
+ * @param out Pointer to store the copy of the object
+ * @param source Original object to copy
+ */
+GIT_EXTERN(int) git_blob_dup(git_blob **out, git_blob *source);
+
 /** @} */
 GIT_END_DECL
 #endif

data/vendor/libgit2/include/git2/commit.h

@@ -394,6 +394,82 @@ GIT_EXTERN(int) git_commit_amend(
 	const char *message,
 	const git_tree *tree);
 
+/**
+ * Create a commit and write it into a buffer
+ *
+ * Create a commit as with `git_commit_create()` but instead of
+ * writing it to the objectdb, write the contents of the object into a
+ * buffer.
+ *
+ * @param out the buffer into which to write the commit object content
+ *
+ * @param repo Repository where the referenced tree and parents live
+ *
+ * @param author Signature with author and author time of commit
+ *
+ * @param committer Signature with committer and * commit time of commit
+ *
+ * @param message_encoding The encoding for the message in the
+ *  commit, represented with a standard encoding name.
+ *  E.g. "UTF-8". If NULL, no encoding header is written and
+ *  UTF-8 is assumed.
+ *
+ * @param message Full message for this commit
+ *
+ * @param tree An instance of a `git_tree` object that will
+ *  be used as the tree for the commit. This tree object must
+ *  also be owned by the given `repo`.
+ *
+ * @param parent_count Number of parents for this commit
+ *
+ * @param parents Array of `parent_count` pointers to `git_commit`
+ *  objects that will be used as the parents for this commit. This
+ *  array may be NULL if `parent_count` is 0 (root commit). All the
+ *  given commits must be owned by the `repo`.
+ *
+ * @return 0 or an error code
+ */
+GIT_EXTERN(int) git_commit_create_buffer(
+	git_buf *out,
+	git_repository *repo,
+	const git_signature *author,
+	const git_signature *committer,
+	const char *message_encoding,
+	const char *message,
+	const git_tree *tree,
+	size_t parent_count,
+	const git_commit *parents[]);
+
+/**
+ * Create a commit object from the given buffer and signature
+ *
+ * Given the unsigned commit object's contents, its signature and the
+ * header field in which to store the signature, attach the signature
+ * to the commit and write it into the given repository.
+ *
+ * @param out the resulting commit id
+ * @param commit_content the content of the unsigned commit object
+ * @param signature the signature to add to the commit
+ * @param signature_field which header field should contain this
+ * signature. Leave `NULL` for the default of "gpgsig"
+ * @return 0 or an error code
+ */
+GIT_EXTERN(int) git_commit_create_with_signature(
+	git_oid *out,
+	git_repository *repo,
+	const char *commit_content,
+	const char *signature,
+	const char *signature_field);
+
+/**
+ * Create an in-memory copy of a commit. The copy must be explicitly
+ * free'd or it will leak.
+ *
+ * @param out Pointer to store the copy of the commit
+ * @param source Original commit to copy
+ */
+GIT_EXTERN(int) git_commit_dup(git_commit **out, git_commit *source);
+
 /** @} */
 GIT_END_DECL
 #endif

data/vendor/libgit2/include/git2/common.h

@@ -109,9 +109,27 @@ GIT_EXTERN(void) git_libgit2_version(int *major, int *minor, int *rev);
  * was compiled
  */
 typedef enum {
+  /**
+   * If set, libgit2 was built thread-aware and can be safely used from multiple
+   * threads.
+   */
 	GIT_FEATURE_THREADS	= (1 << 0),
+  /**
+   * If set, libgit2 was built with and linked against a TLS implementation.
+   * Custom TLS streams may still be added by the user to support HTTPS
+   * regardless of this.
+   */
 	GIT_FEATURE_HTTPS	= (1 << 1),
+  /**
+   * If set, libgit2 was built with and linked against libssh2. A custom
+   * transport may still be added by the user to support libssh2 regardless of
+   * this.
+   */
 	GIT_FEATURE_SSH		= (1 << 2),
+  /**
+   * If set, libgit2 was built with support for sub-second resolution in file
+   * modification times.
+   */
 	GIT_FEATURE_NSEC	= (1 << 3),
 } git_feature_t;
 
@@ -158,6 +176,7 @@ typedef enum {
 	GIT_OPT_SET_USER_AGENT,
 	GIT_OPT_ENABLE_STRICT_OBJECT_CREATION,
 	GIT_OPT_SET_SSL_CIPHERS,
+	GIT_OPT_GET_USER_AGENT,
 } git_libgit2_opt_t;
 
 /**
@@ -268,7 +287,8 @@ typedef enum {
  *		> to ensure that all inputs to the new objects are valid.  For
  *		> example, when this is enabled, the parent(s) and tree inputs
  *		> will be validated when creating a new commit.  This defaults
- *		> to disabled.
+ *		> to enabled.
+ *
  *	* opts(GIT_OPT_SET_SSL_CIPHERS, const char *ciphers)
  *
  *		> Set the SSL ciphers use for HTTPS connections.

data/vendor/libgit2/include/git2/describe.h

@@ -44,8 +44,8 @@ typedef enum {
 typedef struct git_describe_options {
 	unsigned int version;
 
-	unsigned int max_candidates_tags; /** default: 10 */
-	unsigned int describe_strategy; /** default: GIT_DESCRIBE_DEFAULT */
+	unsigned int max_candidates_tags; /**< default: 10 */
+	unsigned int describe_strategy; /**< default: GIT_DESCRIBE_DEFAULT */
 	const char *pattern;
 	/**
 	 * When calculating the distance from the matching tag or
@@ -105,6 +105,9 @@ typedef struct {
 
 GIT_EXTERN(int) git_describe_init_format_options(git_describe_format_options *opts, unsigned int version);
 
+/**
+ * A struct that stores the result of a describe operation.
+ */
 typedef struct git_describe_result git_describe_result;
 
 /**

data/vendor/libgit2/include/git2/diff.h

@@ -264,7 +264,7 @@ typedef enum {
  * link, a submodule commit id, or even a tree (although that only if you
  * are tracking type changes or ignored/untracked directories).
  *
- * The `oid` is the `git_oid` of the item.  If the entry represents an
+ * The `id` is the `git_oid` of the item.  If the entry represents an
  * absent side of a diff (e.g. the `old_file` of a `GIT_DELTA_ADDED` delta),
  * then the oid will be zeroes.
  *
@@ -277,6 +277,11 @@ typedef enum {
  *
  * `mode` is, roughly, the stat() `st_mode` value for the item.  This will
  * be restricted to one of the `git_filemode_t` values.
+ *
+ * The `id_abbrev` represents the known length of the `id` field, when
+ * converted to a hex string.  It is generally `GIT_OID_HEXSZ`, unless this
+ * delta was created from reading a patch file, in which case it may be
+ * abbreviated to something reasonable, like 7 characters.
  */
 typedef struct {
 	git_oid     id;
@@ -284,6 +289,7 @@ typedef struct {
 	git_off_t   size;
 	uint32_t    flags;
 	uint16_t    mode;
+	uint16_t    id_abbrev;
 } git_diff_file;
 
 /**
@@ -448,6 +454,8 @@ typedef int (*git_diff_file_cb)(
 	float progress,
 	void *payload);
 
+#define GIT_DIFF_HUNK_HEADER_SIZE	128
+
 /**
  * When producing a binary diff, the binary data returned will be
  * either the deflated full ("literal") contents of the file, or
@@ -482,6 +490,14 @@ typedef struct {
 
 /** Structure describing the binary contents of a diff. */
 typedef struct {
+	/**
+	 * Whether there is data in this binary structure or not.  If this
+	 * is `1`, then this was produced and included binary content.  If
+	 * this is `0` then this was generated knowing only that a binary
+	 * file changed but without providing the data, probably from a patch
+	 * that said `Binary files a/file.txt and b/file.txt differ`.
+	 */
+	unsigned int contains_data;
 	git_diff_binary_file old_file; /**< The contents of the old file. */
 	git_diff_binary_file new_file; /**< The contents of the new file. */
 } git_diff_binary;
@@ -499,12 +515,12 @@ typedef int(*git_diff_binary_cb)(
  * Structure describing a hunk of a diff.
  */
 typedef struct {
-	int    old_start;     /**< Starting line number in old_file */
-	int    old_lines;     /**< Number of lines in old_file */
-	int    new_start;     /**< Starting line number in new_file */
-	int    new_lines;     /**< Number of lines in new_file */
-	size_t header_len;    /**< Number of bytes in header text */
-	char   header[128];   /**< Header text, NUL-byte terminated */
+	int    old_start;     /** Starting line number in old_file */
+	int    old_lines;     /** Number of lines in old_file */
+	int    new_start;     /** Starting line number in new_file */
+	int    new_lines;     /** Number of lines in new_file */
+	size_t header_len;    /** Number of bytes in header text */
+	char   header[GIT_DIFF_HUNK_HEADER_SIZE];   /** Header text, NUL-byte terminated */
 } git_diff_hunk;
 
 /**
@@ -1046,6 +1062,21 @@ GIT_EXTERN(int) git_diff_print(
 	git_diff_line_cb print_cb,
 	void *payload);
 
+/**
+ * Produce the complete formatted text output from a diff into a
+ * buffer.
+ *
+ * @param out A pointer to a user-allocated git_buf that will
+ *            contain the diff text
+ * @param diff A git_diff generated by one of the above functions.
+ * @param format A git_diff_format_t value to pick the text format.
+ * @return 0 on success or error code
+ */
+GIT_EXTERN(int) git_diff_to_buf(
+	git_buf *out,
+	git_diff *diff,
+	git_diff_format_t format);
+
 /**@}*/
 
 
@@ -1166,6 +1197,30 @@ GIT_EXTERN(int) git_diff_buffers(
 	git_diff_line_cb line_cb,
 	void *payload);
 
+/**
+ * Read the contents of a git patch file into a `git_diff` object.
+ *
+ * The diff object produced is similar to the one that would be
+ * produced if you actually produced it computationally by comparing
+ * two trees, however there may be subtle differences.  For example,
+ * a patch file likely contains abbreviated object IDs, so the
+ * object IDs in a `git_diff_delta` produced by this function will
+ * also be abbreviated.
+ *
+ * This function will only read patch files created by a git
+ * implementation, it will not read unified diffs produced by
+ * the `diff` program, nor any other types of patch files.
+ *
+ * @param out A pointer to a git_diff pointer that will be allocated.
+ * @param content The contents of a patch file
+ * @param content_len The length of the patch file contents
+ * @return 0 or an error code
+ */
+GIT_EXTERN(int) git_diff_from_buffer(
+	git_diff **out,
+	const char *content,
+	size_t content_len);
+
 /**
  * This is an opaque structure which is allocated by `git_diff_get_stats`.
  * You are responsible for releasing the object memory when done, using the