X-Git-Url: http://git.ithinksw.org/philo.git/blobdiff_plain/585c315fde9781b72e1bacd430877c1e5b110e90..2f90757a89424650440d684e08cbf53d98cec8fd:/models/base.py

diff --git a/models/base.py b/models/base.py
index 1b6e60f..ae15d16 100644
--- a/models/base.py
+++ b/models/base.py
@@ -128,10 +128,15 @@ class ManyToManyValue(AttributeValue):
 		# Value is probably a queryset - but allow any iterable.
 		
 		# These lines shouldn't be necessary; however, if value is an EmptyQuerySet,
-		# the code won't work without them. Unclear why...
+		# the code (specifically the object_id__in query) won't work without them. Unclear why...
 		if not value:
 			value = []
 		
+		# Before we can fiddle with the many-to-many to foreignkeyvalues, we need
+		# a pk.
+		if self.pk is None:
+			self.save()
+		
 		if isinstance(value, models.query.QuerySet):
 			value = value.values_list('id', flat=True)
 		
@@ -277,34 +282,85 @@ class TreeManager(models.Manager):
 	def roots(self):
 		return self.filter(parent__isnull=True)
 	
-	def get_with_path(self, path, root=None, absolute_result=True, pathsep='/'):
+	def get_with_path(self, path, root=None, absolute_result=True, pathsep='/', field='slug'):
 		"""
-		Returns the object with the path, or None if there is no object with that path,
-		unless absolute_result is set to False, in which case it returns a tuple containing
-		the deepest object found along the path, and the remainder of the path after that
-		object as a string (or None in the case that there is no remaining path).
+		Returns the object with the path, unless absolute_result is set to False, in which
+		case it returns a tuple containing the deepest object found along the path, and the
+		remainder of the path after that object as a string (or None if there is no remaining
+		path). Raises a DoesNotExist exception if no object is found with the given path.
 		"""
-		slugs = path.split(pathsep)
-		obj = root
-		remaining_slugs = list(slugs)
-		remainder = None
-		for slug in slugs:
-			remaining_slugs.remove(slug)
-			if slug: # ignore blank slugs, handles for multiple consecutive pathseps
+		segments = path.split(pathsep)
+		
+		# Check for a trailing pathsep so we can restore it later.
+		trailing_pathsep = False
+		if segments[-1] == '':
+			trailing_pathsep = True
+		
+		# Clean out blank segments. Handles multiple consecutive pathseps.
+		while True:
+			try:
+				segments.remove('')
+			except ValueError:
+				break
+		
+		# Special-case a lack of segments. No queries necessary.
+		if not segments:
+			if root is not None:
+				return root, None
+			else:
+				raise self.model.DoesNotExist('%s matching query does not exist.' % self.model._meta.object_name)
+		
+		def make_query_kwargs(segments):
+			kwargs = {}
+			prefix = ""
+			revsegs = list(segments)
+			revsegs.reverse()
+			
+			for segment in revsegs:
+				kwargs["%s%s__exact" % (prefix, field)] = segment
+				prefix += "parent__"
+			
+			kwargs[prefix[:-2]] = root
+			return kwargs
+		
+		def build_path(segments):
+			path = pathsep.join(segments)
+			if trailing_pathsep and segments and segments[-1] != '':
+				path += pathsep
+			return path
+		
+		def find_obj(segments, depth, deepest_found):
+			try:
+				obj = self.get(**make_query_kwargs(segments[:depth]))
+			except self.model.DoesNotExist:
+				if absolute_result:
+					raise
+				
+				depth = (deepest_found + depth)/2
+				if deepest_found == depth:
+					# This should happen if nothing is found with any part of the given path.
+					raise
+				
+				# Try finding one with half the path since the deepest find.
+				return find_obj(segments, depth, deepest_found)
+			else:
+				# Yay! Found one! Could there be a deeper one?
+				if absolute_result:
+					return obj
+				
+				deepest_found = depth
+				depth = (len(segments) + depth)/2
+				
+				if deepest_found == depth:
+					return obj, build_path(segments[deepest_found:]) or None
+				
 				try:
-					obj = self.get(slug__exact=slug, parent__exact=obj)
+					return find_obj(segments, depth, deepest_found)
 				except self.model.DoesNotExist:
-					if absolute_result:
-						obj = None
-					remaining_slugs.insert(0, slug)
-					remainder = pathsep.join(remaining_slugs)
-					break
-		if obj:
-			if absolute_result:
-				return obj
-			else:
-				return (obj, remainder)
-		raise self.model.DoesNotExist('%s matching query does not exist.' % self.model._meta.object_name)
+					# Then the deepest one was already found.
+					return obj, build_path(segments[deepest_found:])
+		
+		return find_obj(segments, len(segments), 0)
 
 
 class TreeModel(models.Model):