Added method to obtain a full sha from a partial sha, for each of the databases. The IndexFile has a new method to retrieve an index from a partial sha, instead of from a full sha, to provide the required functionality

Author: Byron

db/git.py

@@ -9,11 +9,33 @@
 from ref import ReferenceDB
 
 from gitdb.util import LazyMixin
-from gitdb.exc import InvalidDBRoot
+from gitdb.exc import (
+						InvalidDBRoot, 
+						BadObject, 
+						AmbiguousObjectName
+						)
 import os
 
+from gitdb.util import hex_to_bin
+
 __all__ = ('GitDB', )
 
+
+def _databases_recursive(database, output):
+	"""Fill output list with database from db, in order. Deals with Loose, Packed 
+	and compound databases."""
+	if isinstance(database, CompoundDB):
+		compounds = list()
+		dbs = database.databases()
+		output.extend(db for db in dbs if not isinstance(db, CompoundDB))
+		for cdb in (db for db in dbs if isinstance(db, CompoundDB)):
+			_databases_recursive(cdb, output)
+	else:
+		output.append(database)
+	# END handle database type
+	
+
+
 class GitDB(FileDBBase, ObjectDBW, CompoundDB):
 	"""A git-style object database, which contains all objects in the 'objects'
 	subdirectory"""
@@ -71,4 +93,45 @@ def ostream(self):
 
 	def set_ostream(self, ostream):
 		return self._loose_db.set_ostream(ostream)
+		
 	#} END objectdbw interface
+	
+	#{ Interface 
+	
+	def partial_to_complete_sha_hex(self, partial_hexsha):
+		"""
+		:return: 20 byte binary sha1 from the given less-than-40 byte hexsha
+		:param partial_hexsha: hexsha with less than 40 byte
+		:raise AmbiguousObjectName: """
+		databases = list()
+		_databases_recursive(self, databases)
+		
+		if len(partial_hexsha) % 2 != 0:
+			partial_binsha = hex_to_bin(partial_hexsha + "0")
+		else:
+			partial_binsha = hex_to_bin(partial_hexsha)
+		# END assure successful binary conversion 
+		
+		candidate = None
+		for db in databases:
+			full_bin_sha = None
+			try:
+				if isinstance(db, LooseObjectDB):
+					full_bin_sha = db.partial_to_complete_sha_hex(partial_hexsha)
+				else:
+					full_bin_sha = db.partial_to_complete_sha(partial_binsha)
+				# END handle database type
+			except BadObject:
+				continue
+			# END ignore bad objects
+			if full_bin_sha:
+				if candidate and candidate != full_bin_sha:
+					raise AmbiguousObjectName(partial_hexsha)
+				candidate = full_bin_sha
+			# END handle candidate
+		# END for each db
+		if not candidate:
+			raise BadObject(partial_binsha)
+		return candidate
+		
+	#} END interface 

db/loose.py

@@ -7,7 +7,8 @@
 
 from gitdb.exc import (
 	InvalidDBRoot, 
-	BadObject, 
+	BadObject,
+	AmbiguousObjectName
 	)
 
 from gitdb.stream import (
@@ -102,6 +103,23 @@ def readable_db_object_path(self, hexsha):
 		# END handle cache
 		raise BadObject(hexsha)
 
+	def partial_to_complete_sha_hex(self, partial_hexsha):
+		""":return: 20 byte binary sha1 string which matches the given name uniquely
+		:param name: hexadecimal partial name
+		:raise AmbiguousObjectName: 
+		:raise BadObject: """
+		candidate = None
+		for binsha in self.sha_iter():
+			if bin_to_hex(binsha).startswith(partial_hexsha):
+				# it can't ever find the same object twice
+				if candidate is not None:
+					raise AmbiguousObjectName(partial_hexsha)
+				candidate = binsha
+		# END for each object
+		if candidate is None:
+			raise BadObject(partial_hexsha)
+		return candidate
+		
 	#} END interface
 
 	def _map_loose_object(self, sha):

db/pack.py

@@ -10,6 +10,7 @@
 from gitdb.exc import (
 							BadObject,
 							UnsupportedOperation,
+							AmbiguousObjectName
 						)
 
 from gitdb.pack import PackEntity
@@ -175,5 +176,26 @@ def update_cache(self, force=False):
 	def entities(self):
 		""":return: list of pack entities operated upon by this database"""
 		return [ item[1] for item in self._entities ]
+		
+	def partial_to_complete_sha(self, partial_binsha):
+		""":return: 20 byte sha as inferred by the given partial binary sha
+		:raise AmbiguousObjectName: 
+		:raise BadObject: """
+		candidate = None
+		for item in self._entities:
+			item_index = item[1].index().partial_sha_to_index(partial_binsha)
+			if item_index is not None:
+				sha = item[1].index().sha(item_index)
+				if candidate and candidate != sha:
+					raise AmbiguousObjectName(partial_binsha)
+				candidate = sha
+			# END handle full sha could be found
+		# END for each entity
+		
+		if candidate:
+			return candidate
+		
+		# still not found ?
+		raise BadObject(partial_binsha)
 
 	#} END interface

exc.py

@@ -13,7 +13,11 @@ class BadObject(ODBError):
 
 	def __str__(self):
 		return "BadObject: %s" % to_hex_sha(self.args[0])
-	
+
+class AmbiguousObjectName(ODBError):
+	"""Thrown if a possibly shortened name does not uniquely represent a single object
+	in the database"""
+
 class BadObjectType(ODBError):
 	"""The object had an unsupported type"""
 

pack.py

@@ -302,7 +302,53 @@ def sha_to_index(self, sha):
 			# END handle midpoint
 		# END bisect
 		return None
-	
+		
+	def partial_sha_to_index(self, partial_sha):
+		""":return: index as in `sha_to_index` or None if the sha was not found in this
+		index file
+		:param partial_sha: an at least two bytes of a partial sha
+		:raise AmbiguousObjectName:"""
+		if len(partial_sha) < 2:
+			raise ValueError("Require at least 2 bytes of partial sha")
+		
+		first_byte = ord(partial_sha[0])
+		get_sha = self.sha
+		lo = 0					# lower index, the left bound of the bisection
+		if first_byte != 0:
+			lo = self._fanout_table[first_byte-1]
+		hi = self._fanout_table[first_byte]		# the upper, right bound of the bisection
+		
+		len_partial = len(partial_sha)
+		# fill the partial to full 20 bytes
+		filled_sha = partial_sha + '\0'*(20 - len_partial)
+		
+		# find lowest 
+		while lo < hi:
+			mid = (lo + hi) / 2
+			c = cmp(filled_sha, get_sha(mid))
+			if c < 0:
+				hi = mid
+			elif not c:
+				# perfect match
+				lo = mid
+				break
+			else:
+				lo = mid + 1
+			# END handle midpoint
+		# END bisect
+		if lo < self.size:
+			cur_sha = get_sha(lo)
+			if cur_sha[:len_partial] == partial_sha:
+				next_sha = None
+				if lo+1 < self.size:
+					next_sha = get_sha(lo+1)
+				if next_sha and next_sha == cur_sha:
+					raise AmbiguousObjectName(partial_sha)
+				return lo
+			# END if we have a match
+		# END if we found something
+		return None
+		
 	if 'PackIndexFile_sha_to_index' in globals():
 		# NOTE: Its just about 25% faster, the major bottleneck might be the attr 
 		# accesses

test/db/test_git.py

@@ -1,7 +1,8 @@
 from lib import *
+from gitdb.exc import BadObject
 from gitdb.db import GitDB
 from gitdb.base import OStream, OInfo
-from gitdb.util import hex_to_bin
+from gitdb.util import hex_to_bin, bin_to_hex
 
 class TestGitDB(TestDBBase):
 
@@ -16,7 +17,15 @@ def test_reading(self):
 		assert isinstance(gdb.info(gitdb_sha), OInfo)
 		assert isinstance(gdb.stream(gitdb_sha), OStream)
 		assert gdb.size() > 200
-		assert len(list(gdb.sha_iter())) == gdb.size()
+		sha_list = list(gdb.sha_iter())
+		assert len(sha_list) == gdb.size()
+		
+		# test partial shas
+		for binsha in sha_list:
+			assert gdb.partial_to_complete_sha_hex(bin_to_hex(binsha)[:8]) == binsha
+		# END for each sha
+		
+		self.failUnlessRaises(BadObject, gdb.partial_to_complete_sha_hex, "0000")
 
 	@with_rw_directory
 	def test_writing(self, path):

test/db/test_loose.py

@@ -1,10 +1,12 @@
 from lib import *
 from gitdb.db import LooseObjectDB
+from gitdb.exc import BadObject
+from gitdb.util import bin_to_hex
 
 class TestLooseDB(TestDBBase):
 
 	@with_rw_directory
-	def test_writing(self, path):
+	def test_basics(self, path):
 		ldb = LooseObjectDB(path)
 
 		# write data
@@ -16,3 +18,13 @@ def test_writing(self, path):
 		assert shas and len(shas[0]) == 20
 
 		assert len(shas) == ldb.size()
+		
+		# verify find short object
+		long_sha = bin_to_hex(shas[-1])
+		for short_sha in (long_sha[:20], long_sha[:5]):
+			assert bin_to_hex(ldb.partial_to_complete_sha_hex(short_sha)) == long_sha
+		# END for each sha
+		
+		self.failUnlessRaises(BadObject, ldb.partial_to_complete_sha_hex, '0000')
+		# raises if no object could be foudn
+		

test/db/test_pack.py

@@ -2,6 +2,8 @@
 from gitdb.db import PackedDB
 from gitdb.test.lib import fixture_path
 
+from gitdb.exc import BadObject, AmbiguousObjectName
+
 import os
 import random
 
@@ -44,3 +46,25 @@ def test_writing(self, path):
 			info = pdb.info(sha)
 			stream = pdb.stream(sha)
 		# END for each sha to query
+		
+		
+		# test short finding - be a bit more brutal here
+		max_bytes = 19
+		min_bytes = 2
+		num_ambiguous = 0
+		for i, sha in enumerate(sha_list):
+			short_sha = sha[:max((i % max_bytes), min_bytes)]
+			try:
+				assert pdb.partial_to_complete_sha(short_sha) == sha
+			except AmbiguousObjectName:
+				num_ambiguous += 1
+				pass # valid, we can have short objects
+			# END exception handling
+		# END for each sha to find
+		
+		# we should have at least one ambiguous, considering the small sizes
+		# but in our pack, there is no ambigious ... 
+		# assert num_ambiguous
+		
+		# non-existing
+		self.failUnlessRaises(BadObject, pdb.partial_to_complete_sha, "\0\0")

test/test_pack.py

@@ -57,7 +57,13 @@ def _assert_index_file(self, index, version, size):
 			assert entry[0] == index.offset(oidx)
 			assert entry[1] == sha
 			assert entry[2] == index.crc(oidx)
+			
+			# verify partial sha
+			for l in (4,8,11,17,20):
+				assert index.partial_sha_to_index(sha[:l]) == oidx
+			
 		# END for each object index in indexfile
+		self.failUnlessRaises(ValueError, index.partial_sha_to_index, "\0")
 
 
 	def _assert_pack_file(self, pack, version, size):