path: root/git/db/py/base.py

# Copyright (C) 2010, 2011 Sebastian Thiel (byronimo@gmail.com) and contributors
#
# This module is part of GitDB and is released under
# the New BSD License: http://www.opensource.org/licenses/bsd-license.php
"""Contains basic implementations for the interface building blocks"""
from git.db.interface import *

from git.util import (
		pool,
		join,
		isfile,
		normpath,
		abspath,
		dirname,
		LazyMixin, 
		hex_to_bin,
		bin_to_hex,
		expandvars,
		expanduser,
		exists,
		is_git_dir,
	)

from git.index import IndexFile
from git.config import GitConfigParser
from git.exc import 	(
						BadObject, 
						AmbiguousObjectName,
						InvalidGitRepositoryError,
						NoSuchPathError
						)

from async import ChannelThreadTask

from itertools import chain
import sys
import os


__all__ = (	'PureObjectDBR', 'PureObjectDBW', 'PureRootPathDB', 'PureCompoundDB', 
			'PureConfigurationMixin', 'PureRepositoryPathsMixin', 'PureAlternatesFileMixin',
			'PureIndexDB')
                                                                        

class PureObjectDBR(ObjectDBR):
	
	#{ Query Interface 
		
	def has_object_async(self, reader):
		task = ChannelThreadTask(reader, str(self.has_object_async), lambda sha: (sha, self.has_object(sha)))
		return pool.add_task(task) 
		
	def info_async(self, reader):
		task = ChannelThreadTask(reader, str(self.info_async), self.info)
		return pool.add_task(task)
		
	def stream_async(self, reader):
		# base implementation just uses the stream method repeatedly
		task = ChannelThreadTask(reader, str(self.stream_async), self.stream)
		return pool.add_task(task)
	
	def partial_to_complete_sha_hex(self, partial_hexsha):
		len_partial_hexsha = len(partial_hexsha)
		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
		return self.partial_to_complete_sha(partial_binsha, len(partial_hexsha))
	
	#} END query interface
	
	
class PureObjectDBW(ObjectDBW):
	
	def __init__(self, *args, **kwargs):
		try:
			super(PureObjectDBW, self).__init__(*args, **kwargs)
		except TypeError:
			pass
		#END handle py 2.6 
		self._ostream = None
	
	#{ Edit Interface
	def set_ostream(self, stream):
		cstream = self._ostream
		self._ostream = stream
		return cstream
		
	def ostream(self):
		return self._ostream
	
	def store_async(self, reader):
		task = ChannelThreadTask(reader, str(self.store_async), self.store) 
		return pool.add_task(task)
	
	#} END edit interface
	

class PureRootPathDB(RootPathDB):
	
	def __init__(self, root_path):
		self._root_path = root_path
		super(PureRootPathDB, self).__init__(root_path)
		
		
	#{ Interface 
	def root_path(self):
		return self._root_path
	
	def db_path(self, rela_path):
		return join(self._root_path, rela_path)
	#} END interface
		

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 PureCompoundDB(CompoundDB, PureObjectDBR, LazyMixin, CachingDB):
	def _set_cache_(self, attr):
		if attr == '_dbs':
			self._dbs = list()
		else:
			super(PureCompoundDB, self)._set_cache_(attr)
	
	#{ PureObjectDBR interface 
	
	def has_object(self, sha):
		for db in self._dbs:
			if db.has_object(sha):
				return True
		#END for each db
		return False
		
	def info(self, sha):
		for db in self._dbs:
			try:
				return db.info(sha)
			except BadObject:
				pass
		#END for each db
		
	def stream(self, sha):
		for db in self._dbs:
			try:
				return db.stream(sha)
			except BadObject:
				pass
		#END for each db

	def size(self):
		return reduce(lambda x,y: x+y, (db.size() for db in self._dbs), 0)
		
	def sha_iter(self):
		return chain(*(db.sha_iter() for db in self._dbs))
		
	#} END object DBR Interface
	
	#{ Interface
	
	def databases(self):
		return tuple(self._dbs)

	def update_cache(self, force=False):
		# something might have changed, clear everything
		stat = False
		for db in self._dbs:
			if isinstance(db, CachingDB):
				stat |= db.update_cache(force)
			# END if is caching db
		# END for each database to update
		return stat
		
	def partial_to_complete_sha_hex(self, partial_hexsha):
		len_partial_hexsha = len(partial_hexsha)
		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 self._dbs:
			full_bin_sha = None
			try:
				if hasattr(db, 'partial_to_complete_sha_hex'):
					full_bin_sha = db.partial_to_complete_sha_hex(partial_hexsha)
				else:
					full_bin_sha = db.partial_to_complete_sha(partial_binsha, len_partial_hexsha)
				# 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
		
	def partial_to_complete_sha(self, partial_binsha, hex_len):
		"""Simple adaptor to feed into our implementation"""
		return self.partial_to_complete_sha_hex(bin_to_hex(partial_binsha)[:hex_len])
	#} END interface
	
		
class PureRepositoryPathsMixin(RepositoryPathsMixin):
	# slots has no effect here, its just to keep track of used attrs
	__slots__  = ("_git_path", '_bare', '_working_tree_dir')
	
	#{ Configuration 
	repo_dir = '.git'
	objs_dir = 'objects'
	#} END configuration
	
	#{ Subclass Interface
	def _initialize(self, path):
		epath = abspath(expandvars(expanduser(path or os.getcwd())))

		if not exists(epath):
			raise NoSuchPathError(epath)
		#END check file 

		self._working_tree_dir = None
		self._git_path = None
		curpath = epath
		
		# walk up the path to find the .git dir
		while curpath:
			if is_git_dir(curpath):
				self._git_path = curpath
				self._working_tree_dir = os.path.dirname(curpath)
				break
			gitpath = join(curpath, self.repo_dir)
			if is_git_dir(gitpath):
				self._git_path = gitpath
				self._working_tree_dir = curpath
				break
			curpath, dummy = os.path.split(curpath)
			if not dummy:
				break
		# END while curpath
		
		if self._git_path is None:
			raise InvalidGitRepositoryError(epath)
		# END path not found

		self._bare = self._working_tree_dir is None
		if hasattr(self, 'config_reader'):
			try:
				self._bare = self.config_reader("repository").getboolean('core','bare') 
			except Exception:
				# lets not assume the option exists, although it should
				pass
			#END handle exception
		#END check bare flag
		self._working_tree_dir = self._bare and None or self._working_tree_dir
		
	#} end subclass interface
	
	#{ Object Interface
	
	def __eq__(self, rhs):
		if hasattr(rhs, 'git_dir'):
			return self.git_dir == rhs.git_dir
		return False
		
	def __ne__(self, rhs):
		return not self.__eq__(rhs)
		
	def __hash__(self):
		return hash(self.git_dir)

	def __repr__(self):
		return "%s(%r)" % (type(self).__name__, self.git_dir)
	
	#} END object interface
	
	#{ Interface
	
	@property
	def is_bare(self):
		return self._bare
		
	@property
	def git_dir(self):
		return self._git_path
		
	@property
	def working_tree_dir(self):
		if self._working_tree_dir is None:
			raise AssertionError("Repository at %s is bare and does not have a working tree directory" % self.git_dir)
		#END assertion
		return dirname(self.git_dir)
	
	@property
	def objects_dir(self):
		return join(self.git_dir, self.objs_dir)
	
	@property
	def working_dir(self):
		if self.is_bare:
			return self.git_dir
		else:
			return self.working_tree_dir
		#END handle bare state
		
	def _mk_description():
		def _get_description(self):
			filename = join(self.git_dir, 'description')
			return file(filename).read().rstrip()
	
		def _set_description(self, descr):
			filename = join(self.git_dir, 'description')
			file(filename, 'w').write(descr+'\n')
			
		return property(_get_description, _set_description, "Descriptive text for the content of the repository")

	description = _mk_description()
	del(_mk_description)
	
	#} END interface
		
		
class PureConfigurationMixin(ConfigurationMixin):
	
	#{ Configuration
	system_config_file_name = "gitconfig"
	repo_config_file_name = "config"
	#} END
	
	def __new__(cls, *args, **kwargs):
		"""This is just a stupid workaround for the evil py2.6 change which makes mixins quite impossible"""
		return super(PureConfigurationMixin, cls).__new__(cls, *args, **kwargs)
	
	def __init__(self, *args, **kwargs):
		"""Verify prereqs"""
		try:
			super(PureConfigurationMixin, self).__init__(*args, **kwargs)
		except TypeError:
			pass
		#END handle code-breaking change in python 2.6
		assert hasattr(self, 'git_dir')
	
	def _path_at_level(self, level ):
		# we do not support an absolute path of the gitconfig on windows , 
		# use the global config instead
		if sys.platform == "win32" and level == "system":
			level = "global"
		#END handle windows
			
		if level == "system":
			return "/etc/%s" % self.system_config_file_name
		elif level == "global":
			return normpath(expanduser("~/.%s" % self.system_config_file_name))
		elif level == "repository":
			return join(self.git_dir, self.repo_config_file_name)
		#END handle level
		
		raise ValueError("Invalid configuration level: %r" % level)
		
	#{ Interface
	
	def config_reader(self, config_level=None):
		files = None
		if config_level is None:
			files = [ self._path_at_level(f) for f in self.config_level ]
		else:
			files = [ self._path_at_level(config_level) ]
		#END handle level
		return GitConfigParser(files, read_only=True)
		
	def config_writer(self, config_level="repository"):
		return GitConfigParser(self._path_at_level(config_level), read_only=False)
	
	
	#} END interface
	
	
class PureIndexDB(IndexDB):
	#{ Configuration
	IndexCls = IndexFile
	#} END configuration
	
	@property
	def index(self):
		return self.IndexCls(self)
	
	
class PureAlternatesFileMixin(object):
	"""Utility able to read and write an alternates file through the alternates property
	It needs to be part of a type with the git_dir or db_path property.
	
	The file by default is assumed to be located at the default location as imposed
	by the standard git repository layout"""
	
	#{ Configuration
	alternates_filepath = os.path.join('info', 'alternates')	# relative path to alternates file
	
	#} END configuration
	
	def __init__(self, *args, **kwargs):
		try:
			super(PureAlternatesFileMixin, self).__init__(*args, **kwargs)
		except TypeError:
			pass
		#END handle py2.6 code breaking changes
		self._alternates_path()	# throws on incompatible type
	
	#{ Interface 
	
	def _alternates_path(self):
		if hasattr(self, 'git_dir'):
			return join(self.git_dir, 'objects', self.alternates_filepath)
		elif hasattr(self, 'db_path'):
			return self.db_path(self.alternates_filepath)
		else:
			raise AssertionError("This mixin requires a parent type with either the git_dir property or db_path method")
		#END handle path
	
	def _get_alternates(self):
		"""The list of alternates for this repo from which objects can be retrieved

		:return: list of strings being pathnames of alternates"""
		alternates_path = self._alternates_path()

		if os.path.exists(alternates_path):
			try:
				f = open(alternates_path)
				alts = f.read()
			finally:
				f.close()
			return alts.strip().splitlines()
		else:
			return list()
		# END handle path exists

	def _set_alternates(self, alts):
		"""Sets the alternates

		:parm alts:
			is the array of string paths representing the alternates at which 
			git should look for objects, i.e. /home/user/repo/.git/objects

		:raise NoSuchPathError:
		:note:
			The method does not check for the existance of the paths in alts
			as the caller is responsible."""
		alternates_path = self._alternates_path() 
		if not alts:
			if isfile(alternates_path):
				os.remove(alternates_path)
		else:
			try:
				f = open(alternates_path, 'w')
				f.write("\n".join(alts))
			finally:
				f.close()
			# END file handling 
		# END alts handling

	alternates = property(_get_alternates, _set_alternates, doc="Retrieve a list of alternates paths or set a list paths to be used as alternates")
	
	#} END interface