1. 12 Feb, 2023 1 commit
  2. 23 Feb, 2022 1 commit
  3. 15 Nov, 2021 1 commit
  4. 17 Oct, 2021 1 commit
    • str: introduce `git_str` for internal, `git_buf` is external · f0e693b1
      libgit2 has two distinct requirements that were previously solved by
      `git_buf`.  We require:
      
      1. A general purpose string class that provides a number of utility APIs
         for manipulating data (eg, concatenating, truncating, etc).
      2. A structure that we can use to return strings to callers that they
         can take ownership of.
      
      By using a single class (`git_buf`) for both of these purposes, we have
      confused the API to the point that refactorings are difficult and
      reasoning about correctness is also difficult.
      
      Move the utility class `git_buf` to be called `git_str`: this represents
      its general purpose, as an internal string buffer class.  The name also
      is an homage to Junio Hamano ("gitstr").
      
      The public API remains `git_buf`, and has a much smaller footprint.  It
      is generally only used as an "out" param with strict requirements that
      follow the documentation.  (Exceptions exist for some legacy APIs to
      avoid breaking callers unnecessarily.)
      
      Utility functions exist to convert a user-specified `git_buf` to a
      `git_str` so that we can call internal functions, then converting it
      back again.
      Edward Thomson committed
  5. 03 Oct, 2019 1 commit
  6. 22 Jun, 2018 1 commit
    • commit: implement function to parse raw data · ab265a35
      Currently, parsing objects is strictly tied to having an ODB object
      available. This makes it hard to parse an object when all that is
      available is its raw object and size. Furthermore, hacking around that
      limitation by directly creating an ODB structure either on stack or on
      heap does not really work that well due to ODB objects being reference
      counted and then automatically free'd when reaching a reference count of
      zero.
      
      Implement a function `git_commit__parse_raw` to parse a commit object
      from a pair of `data` and `size`.
      Patrick Steinhardt committed
  7. 03 Jul, 2017 1 commit
    • Make sure to always include "common.h" first · 0c7f49dd
      Next to including several files, our "common.h" header also declares
      various macros which are then used throughout the project. As such, we
      have to make sure to always include this file first in all
      implementation files. Otherwise, we might encounter problems or even
      silent behavioural differences due to macros or defines not being
      defined as they should be. So in fact, our header and implementation
      files should make sure to always include "common.h" first.
      
      This commit does so by establishing a common include pattern. Header
      files inside of "src" will now always include "common.h" as its first
      other file, separated by a newline from all the other includes to make
      it stand out as special. There are two cases for the implementation
      files. If they do have a matching header file, they will always include
      this one first, leading to "common.h" being transitively included as
      first file. If they do not have a matching header file, they instead
      include "common.h" as first file themselves.
      
      This fixes the outlined problems and will become our standard practice
      for header and source files inside of the "src/" from now on.
      Patrick Steinhardt committed
  8. 01 Dec, 2015 1 commit
  9. 02 Dec, 2013 1 commit
  10. 03 Oct, 2013 1 commit
  11. 10 Jul, 2013 2 commits
  12. 22 Apr, 2013 2 commits
    • Simplify object table parse functions · 3f27127d
      This unifies the object parse functions into one signature that
      takes an odb_object.
      Russell Belfer committed
    • Add callback to git_objects_table · 78606263
      This adds create and free callback to the git_objects_table so
      that more of the creation and destruction of objects can be table
      driven instead of using switch statements.  This also makes the
      semantics of certain object creation functions consistent so that
      we can make better use of function pointers.  This also fixes a
      theoretical error case where an object allocation fails and we
      end up storing NULL into the cache.
      Russell Belfer committed
  13. 08 Jan, 2013 1 commit
  14. 27 Nov, 2012 1 commit
  15. 13 Feb, 2012 1 commit
  16. 18 Sep, 2011 1 commit
    • Cleanup legal data · bb742ede
      1. The license header is technically not valid if it doesn't have a
      copyright signature.
      
      2. The COPYING file has been updated with the different licenses used in
      the project.
      
      3. The full GPLv2 header in each file annoys me.
      Vicent Marti committed
  17. 30 Aug, 2011 1 commit
  18. 12 Aug, 2011 1 commit
  19. 20 Mar, 2011 1 commit
    • I broke your bindings · 72a3fe42
      Hey. Apologies in advance -- I broke your bindings.
      
      This is a major commit that includes a long-overdue redesign of the
      whole object-database structure. This is expected to be the last major
      external API redesign of the library until the first non-alpha release.
      
      Please get your bindings up to date with these changes. They will be
      included in the next minor release. Sorry again!
      
      Major features include:
      
      	- Real caching and refcounting on parsed objects
      	- Real caching and refcounting on objects read from the ODB
      	- Streaming writes & reads from the ODB
      	- Single-method writes for all object types
      	- The external API is now partially thread-safe
      
      The speed increases are significant in all aspects, specially when
      reading an object several times from the ODB (revwalking) and when
      writing big objects to the ODB.
      
      Here's a full changelog for the external API:
      
      blob.h
      ------
      
      	- Remove `git_blob_new`
      	- Remove `git_blob_set_rawcontent`
      	- Remove `git_blob_set_rawcontent_fromfile`
      	- Rename `git_blob_writefile` -> `git_blob_create_fromfile`
      	- Change `git_blob_create_fromfile`:
      		The `path` argument is now relative to the repository's working dir
      	- Add `git_blob_create_frombuffer`
      
      commit.h
      --------
      
      	- Remove `git_commit_new`
      	- Remove `git_commit_add_parent`
      	- Remove `git_commit_set_message`
      	- Remove `git_commit_set_committer`
      	- Remove `git_commit_set_author`
      	- Remove `git_commit_set_tree`
      
      	- Add `git_commit_create`
      	- Add `git_commit_create_v`
      	- Add `git_commit_create_o`
      	- Add `git_commit_create_ov`
      
      tag.h
      -----
      
      	- Remove `git_tag_new`
      	- Remove `git_tag_set_target`
      	- Remove `git_tag_set_name`
      	- Remove `git_tag_set_tagger`
      	- Remove `git_tag_set_message`
      
      	- Add `git_tag_create`
      	- Add `git_tag_create_o`
      
      tree.h
      ------
      
      	- Change `git_tree_entry_2object`:
      		New signature is `(git_object **object_out, git_repository *repo, git_tree_entry *entry)`
      
      	- Remove `git_tree_new`
      	- Remove `git_tree_add_entry`
      	- Remove `git_tree_remove_entry_byindex`
      	- Remove `git_tree_remove_entry_byname`
      	- Remove `git_tree_clearentries`
      	- Remove `git_tree_entry_set_id`
      	- Remove `git_tree_entry_set_name`
      	- Remove `git_tree_entry_set_attributes`
      
      object.h
      ------------
      
      	- Remove `git_object_new
      	- Remove `git_object_write`
      
      	- Change `git_object_close`:
      		This method is now *mandatory*. Not closing an object causes a
      		memory leak.
      
      odb.h
      -----
      
      	- Remove type `git_rawobj`
      	- Remove `git_rawobj_close`
      	- Rename `git_rawobj_hash` -> `git_odb_hash`
      	- Change `git_odb_hash`:
      		New signature is `(git_oid *id, const void *data, size_t len, git_otype type)`
      
      	- Add type `git_odb_object`
      	- Add `git_odb_object_close`
      
      	- Change `git_odb_read`:
      		New signature is `(git_odb_object **out, git_odb *db, const git_oid *id)`
      	- Change `git_odb_read_header`:
      		New signature is `(size_t *len_p, git_otype *type_p, git_odb *db, const git_oid *id)`
      	- Remove `git_odb_write`
      	- Add `git_odb_open_wstream`
      	- Add `git_odb_open_rstream`
      
      odb_backend.h
      -------------
      
      	- Change type `git_odb_backend`:
      		New internal signatures are as follows
      
      			int (* read)(void **, size_t *, git_otype *, struct git_odb_backend *, const git_oid *)
      			int (* read_header)(size_t *, git_otype *, struct git_odb_backend *, const git_oid *)
      			int (* writestream)(struct git_odb_stream **, struct git_odb_backend *, size_t, git_otype)
      			int (* readstream)( struct git_odb_stream **, struct git_odb_backend *, const git_oid *)
      
      	- Add type `git_odb_stream`
      	- Add enum `git_odb_streammode`
      
      Signed-off-by: Vicent Marti <tanoku@gmail.com>
      Vicent Marti committed
  20. 14 Mar, 2011 1 commit
    • Fix the retarded object interdependency system · 6b2a1941
      It's no longer retarded. All object interdependencies are stored as OIDs
      instead of actual objects. This should be hundreds of times faster,
      specially on big repositories. Heck, who knows, maye it doesn't even
      segfault -- wouldn't that be awesome?
      
      What has changed on the API?
      
      	`git_commit_parent`, `git_commit_tree`, `git_tag_target` now return
      	their values through a pointer-to-pointer, and have an error code.
      
      	`git_commit_set_tree` and `git_tag_set_target` now return an error
      	code and may fail.
      
      	`git_repository_free__no_gc` has been deprecated because it's
      	stupid. Since there are no longer any interdependencies between
      	objects, we don't need internal reference counting, and GC
      	never fails or double-free's pointers.
      
      	`git_object_close` now does a very sane thing: marks an object
      	as unused. Closed objects will be eventually free'd from the
      	object cache based on LRU. Please use `git_object_close` from
      	the garbage collector `destroy` method on your bindings. It's
      	100% safe.
      
      	`git_repository_gc` is a new method that forces a garbage collector
      	pass through the repo, to free as many LRU objects as possible.
      	This is useful if we are running out of memory.
      Vicent Marti committed
  21. 18 Dec, 2010 1 commit
  22. 10 Dec, 2010 1 commit
  23. 06 Dec, 2010 1 commit
  24. 02 Dec, 2010 1 commit
  25. 27 Oct, 2010 1 commit
    • Fix internal memory management on the library · 58519018
      String mememory is now managed in a much more sane manner.
      
      Fixes include:
      
      	- git_person email and name is no longer limited to 64 characters
      	- git_tree_entry filename is no longer limited to 255 characters
      	- raw objects are properly opened & closed the minimum amount of
      	times required for parsing
      	- unit tests no longer leak
      	- removed 5 other misc memory leaks as reported by Valgrind
      	- tree writeback no longer segfaults on rare ocassions
      
      The git_person struct is no longer public. It is now managed by the
      library, and getter methods are in place to access its internal
      attributes.
      
      Signed-off-by: Vicent Marti <tanoku@gmail.com>
      Vicent Marti committed
  26. 06 Oct, 2010 1 commit
  27. 19 Sep, 2010 2 commits
    • Add setter methods & write support for git_commit · 0c3596f1
      All the required git_commit_set_XXX methods have been implemented; all
      the attributes of a commit object can now be modified in-memory.
      
      The new method git_object_write() automatically writes back the
      in-memory changes of any object to the repository. So far it only
      supports git_commit objects.
      
      Signed-off-by: Vicent Marti <tanoku@gmail.com>
      Vicent Marti committed
    • Give object structures more descriptive names · f49a2e49
      The 'git_obj' structure is now called 'git_rawobj', since
      it represents a raw object read from the ODB.
      
      The 'git_repository_object' structure is now called 'git_object',
      since it's the base object class for all objects.
      
      Signed-off-by: Vicent Marti <tanoku@gmail.com>
      Vicent Marti committed
  28. 12 Aug, 2010 2 commits
    • Fix object handling in git_repository · f2408cc2
      All loaded objects through git_repository_lookup are properly parsed &
      free'd on failure.
      
      Signed-off-by: Vicent Marti <tanoku@gmail.com>
      Vicent Marti committed
    • Redesigned the walking/object lookup interface · 3315782c
      The old 'git_revpool' object has been removed and
      split into two distinct objects with separate
      functionality, in order to have separate methods for
      object management and object walking.
      
      *	A new object 'git_repository' does the high-level
      	management of a repository's objects (commits, trees,
      	tags, etc) on top of a 'git_odb'.
      
      	Eventually, it will also manage other repository
      	attributes (e.g. tag resolution, references, etc).
      
      	See: src/git/repository.h
      
      *	A new external method
      		'git_repository_lookup(repo, oid, type)'
      	has been added to the 'git_repository' API.
      
      	All object lookups (git_XXX_lookup()) are now
      	wrappers to this method, and duplicated code
      	has been removed. The method does automatic type
      	checking and returns a generic 'git_revpool_object'
      	that can be cast to any specific object.
      
      	See: src/git/repository.h
      
      *	The external methods for object parsing of repository
      	objects (git_XXX_parse()) have been removed.
      
      	Loading objects from the repository is now managed
      	through the 'lookup' functions. These objects are
      	loaded with minimal information, and the relevant
      	parsing is done automatically when the user requests
      	any of the parsed attributes through accessor methods.
      
      	An attribute has been added to 'git_repository' in
      	order to force the parsing of all the repository objects
      	immediately after lookup.
      
      	See: src/git/commit.h
      	See: src/git/tag.h
      	See: src/git/tree.h
      
      *	The previous walking functionality of the revpool
      	is now found in 'git_revwalk', which does the actual
      	revision walking on a repository; the attributes
      	when walking through commits in a database have been
      	decoupled from the actual commit objects.
      	This increases performance when accessing commits
      	during the walk and allows to have several
      	'git_revwalk' instances working at the same time on
      	top of the same repository, without having to load
      	commits in memory several times.
      
      	See: src/git/revwalk.h
      
      *	The old 'git_revpool_table' has been renamed to
      	'git_hashtable' and now works as a generic hashtable
      	with support for any kind of object and custom hash
      	functions.
      
      	See: src/hashtable.h
      
      *	All the relevant unit tests have been updated, renamed
      	and grouped accordingly.
      
      Signed-off-by: Vicent Marti <tanoku@gmail.com>
      Vicent Marti committed
  29. 06 Aug, 2010 1 commit
    • Refactor parsing methods · 364788e1
      The 'parse_oid' and 'parse_person' methods which were used by the commit
      parser are now global so they can be used when parsing other objects.
      
      The 'git_commit_person' struct has been changed to a generic
      'git_person'.
      
      Signed-off-by: Vicent Marti <tanoku@gmail.com>
      Vicent Marti committed
  30. 15 Jul, 2010 3 commits
    • Add external API to access detailed commit attributes · 52f2390b
      The following new external methods have been added:
      
      GIT_EXTERN(const char *) git_commit_message_short(git_commit *commit);
      GIT_EXTERN(const char *) git_commit_message(git_commit *commit);
      GIT_EXTERN(time_t) git_commit_time(git_commit *commit);
      GIT_EXTERN(const git_commit_person *) git_commit_committer(git_commit *commit);
      GIT_EXTERN(const git_commit_person *) git_commit_author(git_commit *commit);
      GIT_EXTERN(const git_tree *) git_commit_tree(git_commit *commit);
      
      A new structure, git_commit_person has been added to represent a
      commit's author or committer.
      
      The parsing of a commit has been split in two phases.
      When adding a commit to the revision pool:
      	- the commit's ODB object is opened
      	- its raw contents are parsed for commit TIME, PARENTS and TREE
      		(the minimal amount of data required to traverse the pool)
      	- the commit's ODB object is closed
      
      When querying for extended information on a commit:
      	- the commit's ODB object is reopened
      	- its raw contents are parsed for the requested information
      	- the commit's ODB object remains open to handle additional queries
      
      New unit tests have been added for the new functionality:
      
      	In t0401-parse: parse_person_test
      	In t0402-details: query_details_test
      
      Signed-off-by: Vicent Marti <tanoku@gmail.com>
      Vicent Marti committed
    • Add support for tree objects in revision pools · 225fe215
      Commits now store pointers to their tree objects.
      Tree objects now work as separate git_revpool_object
      entities.
      Tree objects can be loaded and parsed inedependently
      from commits.
      
      Signed-off-by: Vicent Marti <tanoku@gmail.com>
      Vicent Marti committed
    • Changed revpool's object table to support arbitrary objects · 40721f6b
      git_revpool_object now has a type identifier for each object
      type in a revpool (commits, trees, blobs, etc).
      
      Trees can now be stored in the revision pool.
      
      git_revpool_tableit now supports filtering objects by their
      type when iterating through the object table.
      
      Signed-off-by: Vicent Marti <tanoku@gmail.com>
      Vicent Marti committed
  31. 02 Jun, 2010 4 commits