gitpure 0.1.1__tar.gz → 0.1.2__tar.gz

{gitpure-0.1.1 → gitpure-0.1.2}/.github/workflows/CI.yml

@@ -19,6 +19,25 @@ permissions:
   contents: read
 
 jobs:
+  tests:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5
+      - name: Set up Python
+        uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6
+        with:
+          python-version: '3.13'
+      - name: Set up Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+      - name: Install build tooling
+        run: |
+          python -m pip install --upgrade pip
+          pip install maturin
+      - name: Install project with test extras
+        run: pip install .[test]
+      - name: Run pytest
+        run: pytest -s
+
   linux:
     runs-on: ${{ matrix.platform.runner }}
     strategy:
@@ -37,12 +56,12 @@ jobs:
           - runner: ubuntu-22.04
             target: ppc64le
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5
+      - uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6
         with:
           python-version: 3.x
       - name: Build wheels
-        uses: PyO3/maturin-action@v1
+        uses: PyO3/maturin-action@86b9d133d34bc1b40018696f782949dac11bd380 # v1
         with:
           target: ${{ matrix.platform.target }}
           args: --release --out dist --find-interpreter
@@ -50,7 +69,7 @@ jobs:
           # ring requires a newer version of manylinux on aarch64
           manylinux: ${{ matrix.platform.target == 'aarch64' && '2_28' || 'auto' }}
       - name: Upload wheels
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
         with:
           name: wheels-linux-${{ matrix.platform.target }}
           path: dist
@@ -69,19 +88,19 @@ jobs:
           - runner: ubuntu-22.04
             target: armv7
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5
+      - uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6
         with:
           python-version: 3.x
       - name: Build wheels
-        uses: PyO3/maturin-action@v1
+        uses: PyO3/maturin-action@86b9d133d34bc1b40018696f782949dac11bd380 # v1
         with:
           target: ${{ matrix.platform.target }}
           args: --release --out dist --find-interpreter
           sccache: ${{ !startsWith(github.ref, 'refs/tags/') }}
           manylinux: musllinux_1_2
       - name: Upload wheels
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
         with:
           name: wheels-musllinux-${{ matrix.platform.target }}
           path: dist
@@ -96,19 +115,19 @@ jobs:
           - runner: windows-latest
             target: x86
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5
+      - uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6
         with:
           python-version: 3.x
           architecture: ${{ matrix.platform.target }}
       - name: Build wheels
-        uses: PyO3/maturin-action@v1
+        uses: PyO3/maturin-action@86b9d133d34bc1b40018696f782949dac11bd380 # v1
         with:
           target: ${{ matrix.platform.target }}
           args: --release --out dist --find-interpreter
           sccache: ${{ !startsWith(github.ref, 'refs/tags/') }}
       - name: Upload wheels
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
         with:
           name: wheels-windows-${{ matrix.platform.target }}
           path: dist
@@ -123,33 +142,42 @@ jobs:
           - runner: macos-14
             target: aarch64
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5
+      - uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6
         with:
           python-version: 3.x
       - name: Build wheels
-        uses: PyO3/maturin-action@v1
+        uses: PyO3/maturin-action@86b9d133d34bc1b40018696f782949dac11bd380 # v1
         with:
           target: ${{ matrix.platform.target }}
           args: --release --out dist --find-interpreter
           sccache: ${{ !startsWith(github.ref, 'refs/tags/') }}
       - name: Upload wheels
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
         with:
           name: wheels-macos-${{ matrix.platform.target }}
           path: dist
 
+  success:
+    name: Success
+    runs-on: ubuntu-latest
+    needs: [tests, linux, musllinux, windows, macos, sdist]
+    if: ${{ !cancelled() && !failure() }}
+    steps:
+      - name: Mark success
+        run: echo "All required jobs completed successfully."
+
   sdist:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5
       - name: Build sdist
-        uses: PyO3/maturin-action@v1
+        uses: PyO3/maturin-action@86b9d133d34bc1b40018696f782949dac11bd380 # v1
         with:
           command: sdist
           args: --out dist
       - name: Upload sdist
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
         with:
           name: wheels-sdist
           path: dist
@@ -158,7 +186,7 @@ jobs:
     name: Release
     runs-on: ubuntu-latest
     if: ${{ startsWith(github.ref, 'refs/tags/') || github.event_name == 'workflow_dispatch' }}
-    needs: [linux, musllinux, windows, macos, sdist]
+    needs: [tests, linux, musllinux, windows, macos, sdist]
     permissions:
       # Use to sign the release artifacts
       id-token: write
@@ -170,14 +198,14 @@ jobs:
       name: pypi
       url: https://pypi.org/p/gitpure      
     steps:
-      - uses: actions/download-artifact@v4
+      - uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5
       - name: Generate artifact attestation
-        uses: actions/attest-build-provenance@v2
+        uses: actions/attest-build-provenance@977bb373ede98d70efdf65b84cb5f73e068dcc2a # v3
         with:
           subject-path: 'wheels-*/*'
       - name: Publish to PyPI
         if: ${{ startsWith(github.ref, 'refs/tags/') }}
-        uses: PyO3/maturin-action@v1
+        uses: PyO3/maturin-action@86b9d133d34bc1b40018696f782949dac11bd380 # v1
         with:
           command: upload
           args: --non-interactive --skip-existing wheels-*/*

{gitpure-0.1.1 → gitpure-0.1.2}/Cargo.lock

@@ -406,7 +406,7 @@ checksum = "e629b9b98ef3dd8afe6ca2bd0f89306cec16d43d907889945bc5d6687f2f13c7"
 
 [[package]]
 name = "gitpure"
-version = "0.1.1"
+version = "0.1.2"
 dependencies = [
  "gix",
  "pyo3",
@@ -1814,9 +1814,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3"
-version = "0.25.1"
+version = "0.26.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8970a78afe0628a3e3430376fc5fd76b6b45c4d43360ffd6cdd40bdde72b682a"
+checksum = "7ba0117f4212101ee6544044dae45abe1083d30ce7b29c4b5cbdfa2354e07383"
 dependencies = [
  "indoc",
  "libc",
@@ -1831,19 +1831,18 @@ dependencies = [
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.25.1"
+version = "0.26.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "458eb0c55e7ece017adeba38f2248ff3ac615e53660d7c71a238d7d2a01c7598"
+checksum = "4fc6ddaf24947d12a9aa31ac65431fb1b851b8f4365426e182901eabfb87df5f"
 dependencies = [
- "once_cell",
  "target-lexicon",
 ]
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.25.1"
+version = "0.26.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7114fe5457c61b276ab77c5055f206295b812608083644a5c5b2640c3102565c"
+checksum = "025474d3928738efb38ac36d4744a74a400c901c7596199e20e45d98eb194105"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -1851,9 +1850,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.25.1"
+version = "0.26.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a8725c0a622b374d6cb051d11a0983786448f7785336139c3c94f5aa6bef7e50"
+checksum = "2e64eb489f22fe1c95911b77c44cc41e7c19f3082fc81cce90f657cdc42ffded"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -1863,9 +1862,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.25.1"
+version = "0.26.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4109984c22491085343c05b0dbc54ddc405c3cf7b4374fc533f5c3313a572ccc"
+checksum = "100246c0ecf400b475341b8455a9213344569af29a3c841d29270e53102e0fcf"
 dependencies = [
  "heck",
  "proc-macro2",

{gitpure-0.1.1 → gitpure-0.1.2}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "gitpure"
-version = "0.1.1"
+version = "0.1.2"
 edition = "2024"
 authors = ["Max Dymond <cmeister2@gmail.com>"]
 license = "MIT"
@@ -17,7 +17,7 @@ name = "gitpure"
 crate-type = ["cdylib"]
 
 [dependencies]
-pyo3 = "0.25.0"
+pyo3 = "0.26.0"
 
 [dependencies.gix]
 version = "0.73.0"

{gitpure-0.1.1 → gitpure-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitpure
-Version: 0.1.1
+Version: 0.1.2
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -20,6 +20,7 @@ Classifier: Topic :: Software Development :: Version Control
 Classifier: Topic :: Software Development :: Version Control :: Git
 Classifier: Typing :: Typed
 Requires-Dist: pytest ; extra == 'test'
+Requires-Dist: gitpython>=3.1 ; extra == 'test'
 Provides-Extra: test
 License-File: LICENSE
 Summary: A Python git library implemented in Rust using gitoxide

gitpure-0.1.2/gitpure.pyi

@@ -0,0 +1,108 @@
+"""
+Type stubs for gitpure - A pure git Python module implemented in Rust.
+"""
+
+from pathlib import Path
+from typing import Type
+
+
+class Commit:
+    """Lightweight representation of a git commit."""
+
+    @property
+    def hexsha(self) -> str:
+        """Hexadecimal object id of the commit."""
+        ...
+
+
+class Head:
+    """A named reference to a commit, mirroring GitPython's Head."""
+
+    @property
+    def name(self) -> str:
+        """The short name of the head (branch)."""
+        ...
+
+    @property
+    def commit(self) -> Commit | None:
+        """The commit the head points to, if available."""
+        ...
+
+
+class Tag:
+    """A tag reference with optional peeled commit."""
+
+    @property
+    def name(self) -> str:
+        """The short name of the tag."""
+        ...
+
+    @property
+    def commit(self) -> Commit | None:
+        """The commit the tag ultimately refers to, if available."""
+        ...
+
+class Repo:
+    """A git repository wrapper using gix (gitoxide)."""
+    
+    @property
+    def git_dir(self) -> Path:
+        """
+        Path to the .git directory of the repository.
+        
+        Returns:
+            The absolute path to the .git directory as a pathlib.Path object
+        """
+        ...
+
+    def branches(self) -> list[str]:
+        """Return the names of all local branches in the repository."""
+        ...
+
+    @property
+    def working_tree_dir(self) -> Path | None:
+        """Return the working tree directory of the repository, if it exists."""
+        ...
+
+    @property
+    def is_bare(self) -> bool:
+        """Whether the repository is bare (has no working tree)."""
+        ...
+
+    @property
+    def active_branch(self) -> Head | None:
+        """Current active branch as a Head object, if available."""
+        ...
+
+    @property
+    def head(self) -> Head | None:
+        """HEAD reference as a Head object, if available."""
+        ...
+
+    @property
+    def heads(self) -> list[Head]:
+        """Return all local heads (branches) in the repository."""
+        ...
+
+    @property
+    def tags(self) -> list[Tag]:
+        """Return all tags in the repository."""
+        ...
+    
+    @classmethod
+    def clone_from(cls: Type["Repo"], url: str, to_path: str, bare: bool = False) -> "Repo":
+        """
+        Clone a repository from a URL to a local path.
+        
+        Args:
+            url: The URL of the repository to clone
+            to_path: The local path where the repository should be cloned
+            bare: Whether to create a bare repository (default: False)
+            
+        Returns:
+            A new Repo instance representing the cloned repository
+            
+        Raises:
+            RuntimeError: If the clone operation fails
+        """
+        ...

{gitpure-0.1.1 → gitpure-0.1.2}/pyproject.toml

@@ -45,7 +45,10 @@ Repository = "https://github.com/cmeister2/gitpure"
 "Source Code" = "https://github.com/cmeister2/gitpure"
 
 [project.optional-dependencies]
-test = ["pytest"]
+test = [
+    "pytest",
+    "GitPython>=3.1",
+]
 
 [tool.maturin]
 features = ["pyo3/extension-module"]

gitpure-0.1.2/renovate.json

@@ -0,0 +1,8 @@
+{
+  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+  "extends": [
+    "config:best-practices",
+    ":automergeAll",
+    ":assignAndReview(cmeister2)"
+  ]
+}

gitpure-0.1.2/src/lib.rs

@@ -0,0 +1,329 @@
+use gix::bstr::ByteSlice;
+use gix::Id;
+use pyo3::exceptions::{PyRuntimeError, PyTypeError};
+use pyo3::{prelude::*, types::PyType};
+use std::collections::BTreeSet;
+use std::path::Path;
+
+#[pyclass]
+#[derive(Hash, PartialEq, Eq, PartialOrd, Ord, Clone)]
+struct Commit {
+    hexsha: String,
+}
+
+#[pymethods]
+impl Commit {
+    #[getter]
+    fn hexsha(&self) -> &str {
+        &self.hexsha
+    }
+
+    fn __repr__(&self) -> PyResult<String> {
+        Ok(format!("<gitpure.Commit \"{}\">", self.hexsha))
+    }
+
+    fn __str__(&self) -> PyResult<String> {
+        Ok(self.hexsha.clone())
+    }
+}
+
+impl Commit {
+    fn from_id(id_: Id) -> Self {
+        Self {
+            hexsha: id_.detach().to_string(),
+        }
+    }
+}
+
+#[pyclass]
+#[derive(Hash, PartialEq, Eq, PartialOrd, Ord)]
+struct Head {
+    name: String,
+    commit: Option<Commit>,
+}
+
+#[pymethods]
+impl Head {
+    #[getter]
+    fn name(&self) -> &str {
+        &self.name
+    }
+
+    #[getter]
+    fn commit(&self) -> PyResult<Option<Commit>> {
+        Ok(self.commit.clone())
+    }
+
+    fn __repr__(&self) -> PyResult<String> {
+        Ok(format!("<gitpure.Head \"{}\">", self.name))
+    }
+
+    fn __str__(&self) -> PyResult<String> {
+        Ok(self.name.clone())
+    }
+}
+
+impl Head {
+    fn from_reference(reference: gix::Reference) -> Self {
+        let mut reference = reference;
+        let name = shorten_reference_name(&reference);
+        let commit = reference
+            .peel_to_id_in_place()
+            .ok()
+            .map(Commit::from_id);
+        Self { name, commit }
+    }
+}
+
+#[pyclass(module = "gitpure")]
+#[derive(Hash, PartialEq, Eq, PartialOrd, Ord)]
+struct Tag {
+    name: String,
+    commit: Option<Commit>,
+}
+
+#[pymethods]
+impl Tag {
+    #[getter]
+    fn name(&self) -> &str {
+        &self.name
+    }
+
+    #[getter]
+    fn commit(&self) -> PyResult<Option<Commit>> {
+        Ok(self.commit.clone())
+    }
+
+    fn __repr__(&self) -> PyResult<String> {
+        Ok(format!("<gitpure.Tag \"{}\">", self.name))
+    }
+
+    fn __str__(&self) -> PyResult<String> {
+        Ok(self.name.clone())
+    }
+}
+
+impl Tag {
+    fn from_reference(reference: gix::Reference) -> Self {
+        let mut reference = reference;
+        let name = shorten_reference_name(&reference);
+        let commit = reference
+            .peel_to_id_in_place()
+            .ok()
+            .map(Commit::from_id);
+        Self { name, commit }
+    }
+}
+
+#[pyclass(unsendable)]
+struct Repo {
+    inner: gix::Repository,
+}
+
+fn path_to_python(py: Python<'_>, path: &Path) -> PyResult<PyObject> {
+    let pathlib = py.import("pathlib")?;
+    let path_class = pathlib.getattr("Path")?;
+    Ok(path_class.call1((path.as_os_str(),))?.into())
+}
+
+fn shorten_reference_name(reference: &gix::Reference) -> String {
+    let short_name = reference.name().shorten();
+    match short_name.to_str() {
+        Ok(valid) => valid.to_owned(),
+        Err(_) => short_name.to_string(),
+    }
+}
+
+#[pymethods]
+impl Repo {
+    /// The path to the `.git` directory of the repository.
+    #[getter]
+    fn git_dir(&self, py: Python) -> PyResult<PyObject> {
+        path_to_python(py, self.inner.git_dir())
+    }
+
+    /// The path to the working tree directory, if present.
+    #[getter]
+    fn working_tree_dir(&self, py: Python) -> PyResult<Option<PyObject>> {
+        match self.inner.workdir() {
+            Some(path) => Ok(Some(path_to_python(py, path)?)),
+            None => Ok(None),
+        }
+    }
+
+    /// Returns true if the repository is bare.
+    #[getter]
+    fn is_bare(&self) -> bool {
+        self.inner.workdir().is_none()
+    }
+
+    /// Clone a git repository from the given URL into the specified path.
+    #[classmethod]
+    #[pyo3(signature = (url, to_path, bare=false))]
+    fn clone_from(
+        _cls: &Bound<'_, PyType>,
+        url: &str,
+        to_path: &str,
+        bare: bool,
+    ) -> PyResult<Self> {
+        let target_path = Path::new(to_path);
+
+        // Configure the repository kind based on bare flag
+        let kind = if bare {
+            gix::create::Kind::Bare
+        } else {
+            gix::create::Kind::WithWorktree
+        };
+
+        let mut prepare_clone = gix::clone::PrepareFetch::new(
+            url,
+            target_path,
+            kind,
+            gix::create::Options::default(),
+            gix::open::Options::isolated(),
+        )
+        .map_err(|e| PyRuntimeError::new_err(format!("Failed to prepare clone: {}", e)))?;
+
+        let (mut prepare_checkout, _outcome) = prepare_clone
+            .fetch_then_checkout(gix::progress::Discard, &gix::interrupt::IS_INTERRUPTED)
+            .map_err(|e| PyRuntimeError::new_err(format!("Failed to fetch repository: {}", e)))?;
+
+        if bare {
+            let repo = prepare_checkout.persist();
+            Ok(Repo { inner: repo })
+        } else {
+            let (repo, _checkout_outcome) = prepare_checkout
+                .main_worktree(gix::progress::Discard, &gix::interrupt::IS_INTERRUPTED)
+                .map_err(|e| {
+                    PyRuntimeError::new_err(format!("Failed to checkout worktree: {}", e))
+                })?;
+
+            Ok(Repo { inner: repo })
+        }
+    }
+
+    /// Return the names of all local branches in the repository.
+    fn branches(&self) -> PyResult<Vec<String>> {
+        let platform = self.inner.references().map_err(|err| {
+            PyRuntimeError::new_err(format!("Failed to access references: {err}"))
+        })?;
+
+        let iter = platform.local_branches().map_err(|err| {
+            PyRuntimeError::new_err(format!("Failed to list local branches: {err}"))
+        })?;
+
+        let branches: BTreeSet<String> = iter
+            .map(|reference_result| {
+                reference_result.map_err(|err| {
+                    PyRuntimeError::new_err(format!(
+                        "Failed to load branch reference: {err}"
+                    ))
+                })
+            })
+            .collect::<Result<Vec<_>, _>>()?
+            .into_iter()
+            .map(|reference| shorten_reference_name(&reference))
+            .collect();
+
+        Ok(branches.into_iter().collect())
+    }
+
+    /// Return the path to the current active branch, if any.
+    #[getter]
+    fn active_branch(&self) -> PyResult<Option<Head>> {
+        if self.is_bare() {
+            return Ok(None);
+        }
+
+        let head = self
+            .inner
+            .head()
+            .map_err(|err| PyRuntimeError::new_err(format!("Failed to access HEAD: {err}")))?;
+
+        // If HEAD is detached then raise a TypeError like GitPython does
+        if head.is_detached() {
+            return Err(PyTypeError::new_err(
+                "HEAD is detached; no active branch".to_string(),
+            ));
+        }
+
+        if head.is_unborn() {
+            return Ok(None);
+        }
+
+        Ok(head.try_into_referent().map(Head::from_reference))
+    }
+
+    /// Return the commit id pointed to by HEAD, if available.
+    #[getter]
+    fn head(&self) -> PyResult<Option<Head>> {
+        let head = self
+            .inner
+            .head()
+            .map_err(|err| PyRuntimeError::new_err(format!("Failed to access HEAD: {err}")))?;
+
+        Ok(head.try_into_referent().map(Head::from_reference))
+    }
+
+    /// List all local heads (branches) in the repository.
+    #[getter]
+    fn heads(&self) -> PyResult<Vec<Head>> {
+        let platform = self.inner.references().map_err(|err| {
+            PyRuntimeError::new_err(format!("Failed to access references: {err}"))
+        })?;
+
+        let iter = platform.local_branches().map_err(|err| {
+            PyRuntimeError::new_err(format!("Failed to list local branches: {err}"))
+        })?;
+
+        let heads: BTreeSet<Head> = iter
+            .map(|reference_result| {
+                reference_result.map_err(|err| {
+                    PyRuntimeError::new_err(format!(
+                        "Failed to load branch reference: {err}"
+                    ))
+                })
+            })
+            .collect::<Result<Vec<_>, _>>()?
+            .into_iter()
+            .map(Head::from_reference)
+            .collect::<BTreeSet<Head>>();
+
+        Ok(heads.into_iter().collect())
+    }
+
+    /// List all tags in the repository.
+    #[getter]
+    fn tags(&self) -> PyResult<Vec<Tag>> {
+        let platform = self.inner.references().map_err(|err| {
+            PyRuntimeError::new_err(format!("Failed to access references: {err}"))
+        })?;
+
+        let iter = platform.tags().map_err(|err| {
+            PyRuntimeError::new_err(format!("Failed to list tags: {err}"))
+        })?;
+
+        let tags: BTreeSet<Tag> = iter
+            .map(|reference_result| {
+                reference_result.map_err(|err| {
+                    PyRuntimeError::new_err(format!("Failed to load tag reference: {err}"))
+                })
+            })
+            .collect::<Result<Vec<_>, _>>()?
+            .into_iter()
+            .map(Tag::from_reference)
+            .collect();
+
+        Ok(tags.into_iter().collect())
+    }
+}
+
+/// A pure git Python module implemented in Rust.
+#[pymodule]
+fn gitpure(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    m.add_class::<Commit>()?;
+    m.add_class::<Head>()?;
+    m.add_class::<Tag>()?;
+    m.add_class::<Repo>()?;
+    Ok(())
+}

gitpure-0.1.2/tests/test_repo.py

@@ -0,0 +1,178 @@
+import tempfile
+from pathlib import Path
+
+from git import Repo as GitPythonRepo
+
+from gitpure import Repo
+
+def test_clone_and_git_dir_worktree():
+    """Test cloning a worktree repository and git_dir property"""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        repo_url = "https://github.com/cmeister2/gitpure"
+        repo_path = Path(tmpdir) / "gitpure"
+        repo = Repo.clone_from(repo_url, str(repo_path))
+        
+        # Test basic clone functionality
+        assert (repo_path / ".git").exists()
+        assert (repo_path / "README.md").exists()
+        
+        # Test git_dir property
+        git_dir = repo.git_dir
+        expected_git_dir = repo_path / ".git"
+        
+        # Should return the correct path
+        assert Path(git_dir) == expected_git_dir
+        
+        # The returned path should exist and be a directory
+        assert Path(git_dir).exists()
+        assert Path(git_dir).is_dir()
+        
+        # Should contain typical git directory contents
+        git_dir_path = Path(git_dir)
+        assert (git_dir_path / "HEAD").exists()
+        assert (git_dir_path / "config").exists()
+        assert (git_dir_path / "objects").exists()
+        assert (git_dir_path / "refs").exists()
+        
+        # Test git_dir property type and consistency
+        assert isinstance(git_dir, Path)
+        assert git_dir.is_absolute()
+        
+        # Multiple calls should return the same result
+        git_dir2 = repo.git_dir
+        git_dir3 = repo.git_dir
+        assert git_dir == git_dir2 == git_dir3
+
+        # Metadata parity with GitPython
+        gitpython_repo = GitPythonRepo(str(repo_path))
+
+        gitpython_worktree = gitpython_repo.working_tree_dir
+        assert gitpython_worktree is not None
+        assert repo.working_tree_dir == Path(gitpython_worktree)
+        assert repo.is_bare is False
+        active_branch = repo.active_branch
+        assert active_branch is not None
+        assert active_branch.name == gitpython_repo.active_branch.name
+        assert active_branch.commit is not None
+        assert active_branch.commit.hexsha == gitpython_repo.active_branch.commit.hexsha
+
+        head = repo.head
+        assert head is not None
+        assert head.commit is not None
+        assert head.commit.hexsha == gitpython_repo.head.commit.hexsha
+        gitpure_heads = repo.heads
+        assert isinstance(gitpure_heads, list)
+        assert all(hasattr(head, "name") and hasattr(head, "commit") for head in gitpure_heads)
+
+        assert sorted(head.name for head in gitpure_heads) == sorted(
+            head.name for head in gitpython_repo.heads
+        )
+
+        assert sorted(head.commit.hexsha for head in gitpure_heads if head.commit) == sorted(
+            head.commit.hexsha for head in gitpython_repo.heads if head.commit
+        )
+
+        gitpure_tags = repo.tags
+        assert isinstance(gitpure_tags, list)
+        assert all(hasattr(tag, "name") and hasattr(tag, "commit") for tag in gitpure_tags)
+
+        assert sorted(tag.name for tag in gitpure_tags) == sorted(
+            tag.name for tag in gitpython_repo.tags
+        )
+
+        gitpure_tag_commits = {
+            tag.name: (tag.commit.hexsha if tag.commit else None)
+            for tag in gitpure_tags
+        }
+        gitpython_tag_commits = {
+            tag.name: (tag.commit.hexsha if tag.commit else None)
+            for tag in gitpython_repo.tags
+        }
+        assert gitpure_tag_commits == gitpython_tag_commits
+
+def test_clone_and_git_dir_bare():
+    """Test cloning a bare repository and git_dir property"""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        repo_url = "https://github.com/cmeister2/gitpure"
+        repo_path = Path(tmpdir) / "gitpure.git"
+        repo = Repo.clone_from(repo_url, str(repo_path), bare=True)
+        
+        # Test bare clone functionality
+        # Should NOT have .git subdirectory (it IS the git directory)
+        assert not (repo_path / ".git").exists()
+        
+        # Should have git files directly in the root
+        assert (repo_path / "HEAD").exists()
+        assert (repo_path / "config").exists()
+        assert (repo_path / "objects").exists()
+        assert (repo_path / "refs").exists()
+        
+        # Should NOT have working tree files
+        assert not (repo_path / "README.md").exists()
+        
+        # Test git_dir property for bare repo
+        git_dir = repo.git_dir
+        
+        # For bare repos, git_dir should be the repo directory itself
+        assert Path(git_dir) == repo_path
+        
+        # The returned path should exist and be a directory
+        assert Path(git_dir).exists()
+        assert Path(git_dir).is_dir()
+        
+        # Test git_dir property type
+        assert isinstance(git_dir, Path)
+        assert git_dir.is_absolute()
+
+        # Metadata parity with GitPython
+        gitpython_repo = GitPythonRepo(str(repo_path))
+
+        assert gitpython_repo.working_tree_dir is None
+        assert repo.working_tree_dir is None
+        assert repo.is_bare is True
+        assert repo.active_branch is None
+
+        head = repo.head
+        assert head is not None
+        assert head.commit is not None
+        assert head.commit.hexsha == gitpython_repo.head.commit.hexsha
+        gitpure_heads = repo.heads
+        assert sorted(head.name for head in gitpure_heads) == sorted(
+            head.name for head in gitpython_repo.heads
+        )
+
+        gitpure_tags = repo.tags
+        assert sorted(tag.name for tag in gitpure_tags) == sorted(
+            tag.name for tag in gitpython_repo.tags
+        )
+
+        gitpure_tag_commits = {
+            tag.name: (tag.commit.hexsha if tag.commit else None)
+            for tag in gitpure_tags
+        }
+        gitpython_tag_commits = {
+            tag.name: (tag.commit.hexsha if tag.commit else None)
+            for tag in gitpython_repo.tags
+        }
+        assert gitpure_tag_commits == gitpython_tag_commits
+
+
+def test_branch_listing_matches_gitpython():
+    """Ensure branch listings are aligned with GitPython."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        repo_url = "https://github.com/cmeister2/gitpure"
+        repo_path = Path(tmpdir) / "gitpure"
+        repo = Repo.clone_from(repo_url, str(repo_path))
+
+        gitpure_branches = repo.branches()
+        assert isinstance(gitpure_branches, list)
+        assert all(isinstance(branch, str) for branch in gitpure_branches)
+
+        gitpython_repo = GitPythonRepo(str(repo_path))
+        gitpython_branches = sorted(head.name for head in gitpython_repo.branches)
+
+        assert gitpure_branches == gitpython_branches
+
+        # heads property should mirror branches()
+        gitpure_heads = repo.heads
+        assert [head.name for head in gitpure_heads] == gitpure_branches

gitpure-0.1.1/gitpure.pyi

@@ -1,37 +0,0 @@
-"""
-Type stubs for gitpure - A pure git Python module implemented in Rust.
-"""
-
-from pathlib import Path
-from typing import Type
-
-class Repo:
-    """A git repository wrapper using gix (gitoxide)."""
-    
-    @property
-    def git_dir(self) -> Path:
-        """
-        Path to the .git directory of the repository.
-        
-        Returns:
-            The absolute path to the .git directory as a pathlib.Path object
-        """
-        ...
-    
-    @classmethod
-    def clone_from(cls: Type["Repo"], url: str, to_path: str, bare: bool = False) -> "Repo":
-        """
-        Clone a repository from a URL to a local path.
-        
-        Args:
-            url: The URL of the repository to clone
-            to_path: The local path where the repository should be cloned
-            bare: Whether to create a bare repository (default: False)
-            
-        Returns:
-            A new Repo instance representing the cloned repository
-            
-        Raises:
-            RuntimeError: If the clone operation fails
-        """
-        ...

gitpure-0.1.1/src/lib.rs

@@ -1,73 +0,0 @@
-use pyo3::exceptions::PyRuntimeError;
-use pyo3::{prelude::*, types::PyType};
-use std::path::Path;
-
-#[pyclass(unsendable)]
-struct Repo {
-    inner: gix::Repository,
-}
-
-#[pymethods]
-impl Repo {
-    /// The path to the `.git` directory of the repository.
-    #[getter]
-    fn git_dir(&self, py: Python) -> PyResult<PyObject> {
-        let git_dir_path = self.inner.git_dir();
-        let pathlib = py.import("pathlib")?;
-        let path_class = pathlib.getattr("Path")?;
-        let path_obj = path_class.call1((git_dir_path.as_os_str(),))?;
-        Ok(path_obj.into())
-    }
-
-    /// Clone a git repository from the given URL into the specified path.
-    #[classmethod]
-    #[pyo3(signature = (url, to_path, bare=false))]
-    fn clone_from(
-        _cls: &Bound<'_, PyType>,
-        url: &str,
-        to_path: &str,
-        bare: bool,
-    ) -> PyResult<Self> {
-        let target_path = Path::new(to_path);
-
-        // Configure the repository kind based on bare flag
-        let kind = if bare {
-            gix::create::Kind::Bare
-        } else {
-            gix::create::Kind::WithWorktree
-        };
-
-        let mut prepare_clone = gix::clone::PrepareFetch::new(
-            url,
-            target_path,
-            kind,
-            gix::create::Options::default(),
-            gix::open::Options::isolated(),
-        )
-        .map_err(|e| PyRuntimeError::new_err(format!("Failed to prepare clone: {}", e)))?;
-
-        let (mut prepare_checkout, _outcome) = prepare_clone
-            .fetch_then_checkout(gix::progress::Discard, &gix::interrupt::IS_INTERRUPTED)
-            .map_err(|e| PyRuntimeError::new_err(format!("Failed to fetch repository: {}", e)))?;
-
-        if bare {
-            let repo = prepare_checkout.persist();
-            Ok(Repo { inner: repo })
-        } else {
-            let (repo, _checkout_outcome) = prepare_checkout
-                .main_worktree(gix::progress::Discard, &gix::interrupt::IS_INTERRUPTED)
-                .map_err(|e| {
-                    PyRuntimeError::new_err(format!("Failed to checkout worktree: {}", e))
-                })?;
-
-            Ok(Repo { inner: repo })
-        }
-    }
-}
-
-/// A pure git Python module implemented in Rust.
-#[pymodule]
-fn gitpure(m: &Bound<'_, PyModule>) -> PyResult<()> {
-    m.add_class::<Repo>()?;
-    Ok(())
-}

gitpure-0.1.1/tests/test_repo.py

@@ -1,76 +0,0 @@
-import tempfile
-from pathlib import Path
-
-from gitpure import Repo 
-
-def test_clone_and_git_dir_worktree():
-    """Test cloning a worktree repository and git_dir property"""
-    with tempfile.TemporaryDirectory() as tmpdir:
-        repo_url = "https://github.com/curl/wcurl"
-        repo_path = Path(tmpdir) / "wcurl"
-        repo = Repo.clone_from(repo_url, str(repo_path))
-        
-        # Test basic clone functionality
-        assert (repo_path / ".git").exists()
-        assert (repo_path / "README.md").exists()
-        
-        # Test git_dir property
-        git_dir = repo.git_dir
-        expected_git_dir = repo_path / ".git"
-        
-        # Should return the correct path
-        assert Path(git_dir) == expected_git_dir
-        
-        # The returned path should exist and be a directory
-        assert Path(git_dir).exists()
-        assert Path(git_dir).is_dir()
-        
-        # Should contain typical git directory contents
-        git_dir_path = Path(git_dir)
-        assert (git_dir_path / "HEAD").exists()
-        assert (git_dir_path / "config").exists()
-        assert (git_dir_path / "objects").exists()
-        assert (git_dir_path / "refs").exists()
-        
-        # Test git_dir property type and consistency
-        assert isinstance(git_dir, Path)
-        assert git_dir.is_absolute()
-        
-        # Multiple calls should return the same result
-        git_dir2 = repo.git_dir
-        git_dir3 = repo.git_dir
-        assert git_dir == git_dir2 == git_dir3
-
-def test_clone_and_git_dir_bare():
-    """Test cloning a bare repository and git_dir property"""
-    with tempfile.TemporaryDirectory() as tmpdir:
-        repo_url = "https://github.com/curl/wcurl"
-        repo_path = Path(tmpdir) / "wcurl.git"
-        repo = Repo.clone_from(repo_url, str(repo_path), bare=True)
-        
-        # Test bare clone functionality
-        # Should NOT have .git subdirectory (it IS the git directory)
-        assert not (repo_path / ".git").exists()
-        
-        # Should have git files directly in the root
-        assert (repo_path / "HEAD").exists()
-        assert (repo_path / "config").exists()
-        assert (repo_path / "objects").exists()
-        assert (repo_path / "refs").exists()
-        
-        # Should NOT have working tree files
-        assert not (repo_path / "README.md").exists()
-        
-        # Test git_dir property for bare repo
-        git_dir = repo.git_dir
-        
-        # For bare repos, git_dir should be the repo directory itself
-        assert Path(git_dir) == repo_path
-        
-        # The returned path should exist and be a directory
-        assert Path(git_dir).exists()
-        assert Path(git_dir).is_dir()
-        
-        # Test git_dir property type
-        assert isinstance(git_dir, Path)
-        assert git_dir.is_absolute()