Added export_repository support and corresponding tests for git client.

Signed-off-by: Leander Stephen D'Souza <[email protected]>

Author: leander-dsouza

test/test_git.py

@@ -1,6 +1,7 @@
 """Unit tests for GitClient checkout functionality"""
 
 import os
+import tarfile
 import tempfile
 import unittest
 
@@ -59,5 +60,86 @@ def test_checkout_to_existing_directory(self):
         self.assertFalse(success, 'Checkout should fail for non-empty directory')
 
 
+class TestExportRepository(unittest.TestCase):
+    """Test cases for GitClient export_repository method"""
+
+    def setUp(self):
+        # Create a temporary directory for testing
+        self.test_dir = tempfile.mkdtemp()
+        self.repo_path = os.path.join(self.test_dir, 'test_repo')
+        self.export_dir = os.path.join(self.test_dir, 'exports')
+        os.makedirs(self.export_dir, exist_ok=True)
+
+        self.test_repo_url = 'https://github.com/octocat/Hello-World.git'
+        self.client = GitClient(self.repo_path)
+
+    def tearDown(self):
+        if os.path.exists(self.test_dir):
+            rmtree(self.test_dir)
+
+    def test_export_specific_branch(self):
+        """Test exporting the repository at a specific branch"""
+        success = self.client.checkout(self.test_repo_url, version='test')
+
+        if not success:
+            self.fail('Failed to clone test repository')
+
+        basepath = os.path.join(self.export_dir, 'repo_export')
+        filepath = self.client.export_repository('test', basepath)
+
+        self.assertTrue(os.path.exists(filepath), 'Export file should exist')
+        self.assertGreater(
+            os.path.getsize(filepath), 0, 'Export file should not be empty'
+        )
+        # Verify it's a valid tar.gz file
+        try:
+            if filepath and isinstance(filepath, str):
+                with tarfile.open(filepath, 'r:gz') as tar:
+                    members = tar.getnames()
+                    self.assertIn('README', members, 'Should contain README file')
+            else:
+                self.fail('Exported file path is invalid')
+        except tarfile.ReadError:
+            self.fail('Exported file should be a valid tar.gz archive')
+
+    def test_export_with_local_changes_uses_temp_dir(self):
+        """Test that export uses temp directory when there are local changes"""
+        # First clone the repository
+        success = self.client.checkout(self.test_repo_url)
+        if not success:
+            self.fail('Failed to clone test repository')
+
+        # Create a local change
+        test_file = os.path.join(self.repo_path, 'test_change.txt')
+        with open(test_file, 'w', encoding='utf-8') as f:
+            f.write('test change')
+
+        basepath = os.path.join(self.export_dir, 'local_changes_test')
+        filepath = self.client.export_repository(None, basepath)
+
+        self.assertIsNotNone(filepath, 'Export should succeed even with local changes')
+        self.assertTrue(os.path.exists(filepath), 'Export file should exist')
+        self.assertGreater(
+            os.path.getsize(filepath), 0, 'Export file should not be empty'
+        )
+
+        # Clean up
+        os.remove(test_file)
+
+    def test_export_invalid_branch(self):
+        """Test exporting a non-existent branch should fail gracefully"""
+        success = self.client.checkout(self.test_repo_url)
+
+        if not success:
+            self.fail('Failed to clone test repository')
+
+        basepath = os.path.join(self.export_dir, 'nonexistent_export')
+        result = self.client.export_repository('nonexistent-branch-12345', basepath)
+
+        self.assertEqual(
+            result, False, 'Export should return False for non-existent ref'
+        )
+
+
 if __name__ == '__main__':
     unittest.main()

vcs2l/clients/git.py

@@ -1,5 +1,6 @@
 import os
 import subprocess
+import tempfile
 from shutil import which
 
 from vcs2l.clients.vcs_base import VcsClientBase
@@ -782,6 +783,47 @@ def _check_color(self, cmd):
         if GitClient._config_color_is_auto:
             cmd[1:1] = '-c', 'color.ui=always'
 
+    def export_repository(self, version, basepath):
+        """Export repository to a tar.gz file at the specified version."""
+        if not GitClient.is_repository(self.path):
+            return False
+
+        self._check_executable()
+        filepath = '{0}.tar.gz'.format(basepath)
+
+        # If current version matches export version and no local changes, export directly
+        current_sha = self._get_current_version()
+        export_sha = self._get_version_sha(version) if version else current_sha
+        if current_sha == export_sha and self._has_no_local_changes():
+            cmd = [
+                GitClient._executable,
+                'archive',
+                '--format=tar.gz',
+                '--output={}'.format(filepath),
+                version or 'HEAD',
+            ]
+            result = self._run_command(cmd)
+            if result['returncode'] == 0:
+                return filepath
+
+        # Otherwise use temp directory approach
+        tmpd_path = tempfile.mkdtemp()
+        try:
+            tmpgit = GitClient(tmpd_path)
+            if tmpgit.checkout(self.path, version=version, shallow=False):
+                cmd = [
+                    GitClient._executable,
+                    'archive',
+                    '--format=tar.gz',
+                    '--output={}'.format(filepath),
+                    version or 'HEAD',
+                ]
+                result = tmpgit._run_command(cmd)
+                return filepath if result['returncode'] == 0 else False
+            return False
+        finally:
+            rmtree(tmpd_path)
+
     def checkout(self, url, version=None, verbose=False, shallow=False, timeout=None):
         """Clone a git repository to the specified path and checkout a specific version."""
         if url is None or url.strip() == '':
@@ -867,6 +909,24 @@ def _get_hash_ref_tuples(self, ls_remote_output):
             tuples.append((hash_, ref))
         return tuples
 
+    def _get_current_version(self):
+        """Get current HEAD SHA."""
+        cmd = [GitClient._executable, 'rev-parse', 'HEAD']
+        result = self._run_command(cmd)
+        return result['output'].strip() if result['returncode'] == 0 else None
+
+    def _get_version_sha(self, version):
+        """Get SHA for a given version."""
+        cmd = [GitClient._executable, 'rev-parse', version]
+        result = self._run_command(cmd)
+        return result['output'].strip() if result['returncode'] == 0 else None
+
+    def _has_no_local_changes(self):
+        """Check if there are no local changes."""
+        cmd = [GitClient._executable, 'diff', '--quiet']
+        result = self._run_command(cmd)
+        return result['returncode'] == 0
+
 
 if not GitClient._executable:
     GitClient._executable = which('git')