use libc::{c_char, c_uint, size_t};
use std::ffi::CString;
use std::iter::FusedIterator;
use std::marker;
use std::mem;
use std::ops::Range;
use std::str;
use crate::util::{self, Binding};
use crate::{raw, DiffDelta, IntoCString, Repository, Status};
pub struct StatusOptions {
raw: raw::git_status_options,
pathspec: Vec<CString>,
ptrs: Vec<*const c_char>,
}
#[derive(Copy, Clone)]
pub enum StatusShow {
Index,
Workdir,
IndexAndWorkdir,
}
pub struct Statuses<'repo> {
raw: *mut raw::git_status_list,
_marker: marker::PhantomData<&'repo Repository>,
}
pub struct StatusIter<'statuses> {
statuses: &'statuses Statuses<'statuses>,
range: Range<usize>,
}
pub struct StatusEntry<'statuses> {
raw: *const raw::git_status_entry,
_marker: marker::PhantomData<&'statuses DiffDelta<'statuses>>,
}
impl Default for StatusOptions {
fn default() -> Self {
Self::new()
}
}
impl StatusOptions {
pub fn new() -> StatusOptions {
unsafe {
let mut raw = mem::zeroed();
let r = raw::git_status_init_options(&mut raw, raw::GIT_STATUS_OPTIONS_VERSION);
assert_eq!(r, 0);
StatusOptions {
raw,
pathspec: Vec::new(),
ptrs: Vec::new(),
}
}
}
pub fn show(&mut self, show: StatusShow) -> &mut StatusOptions {
self.raw.show = match show {
StatusShow::Index => raw::GIT_STATUS_SHOW_INDEX_ONLY,
StatusShow::Workdir => raw::GIT_STATUS_SHOW_WORKDIR_ONLY,
StatusShow::IndexAndWorkdir => raw::GIT_STATUS_SHOW_INDEX_AND_WORKDIR,
};
self
}
pub fn pathspec<T: IntoCString>(&mut self, pathspec: T) -> &mut StatusOptions {
let s = util::cstring_to_repo_path(pathspec).unwrap();
self.ptrs.push(s.as_ptr());
self.pathspec.push(s);
self
}
fn flag(&mut self, flag: raw::git_status_opt_t, val: bool) -> &mut StatusOptions {
if val {
self.raw.flags |= flag as c_uint;
} else {
self.raw.flags &= !(flag as c_uint);
}
self
}
pub fn include_untracked(&mut self, include: bool) -> &mut StatusOptions {
self.flag(raw::GIT_STATUS_OPT_INCLUDE_UNTRACKED, include)
}
pub fn include_ignored(&mut self, include: bool) -> &mut StatusOptions {
self.flag(raw::GIT_STATUS_OPT_INCLUDE_IGNORED, include)
}
pub fn include_unmodified(&mut self, include: bool) -> &mut StatusOptions {
self.flag(raw::GIT_STATUS_OPT_INCLUDE_UNMODIFIED, include)
}
pub fn exclude_submodules(&mut self, exclude: bool) -> &mut StatusOptions {
self.flag(raw::GIT_STATUS_OPT_EXCLUDE_SUBMODULES, exclude)
}
pub fn recurse_untracked_dirs(&mut self, include: bool) -> &mut StatusOptions {
self.flag(raw::GIT_STATUS_OPT_RECURSE_UNTRACKED_DIRS, include)
}
pub fn disable_pathspec_match(&mut self, include: bool) -> &mut StatusOptions {
self.flag(raw::GIT_STATUS_OPT_DISABLE_PATHSPEC_MATCH, include)
}
pub fn recurse_ignored_dirs(&mut self, include: bool) -> &mut StatusOptions {
self.flag(raw::GIT_STATUS_OPT_RECURSE_IGNORED_DIRS, include)
}
pub fn renames_head_to_index(&mut self, include: bool) -> &mut StatusOptions {
self.flag(raw::GIT_STATUS_OPT_RENAMES_HEAD_TO_INDEX, include)
}
pub fn renames_index_to_workdir(&mut self, include: bool) -> &mut StatusOptions {
self.flag(raw::GIT_STATUS_OPT_RENAMES_INDEX_TO_WORKDIR, include)
}
pub fn sort_case_sensitively(&mut self, include: bool) -> &mut StatusOptions {
self.flag(raw::GIT_STATUS_OPT_SORT_CASE_SENSITIVELY, include)
}
pub fn sort_case_insensitively(&mut self, include: bool) -> &mut StatusOptions {
self.flag(raw::GIT_STATUS_OPT_SORT_CASE_INSENSITIVELY, include)
}
pub fn renames_from_rewrites(&mut self, include: bool) -> &mut StatusOptions {
self.flag(raw::GIT_STATUS_OPT_RENAMES_FROM_REWRITES, include)
}
pub fn no_refresh(&mut self, include: bool) -> &mut StatusOptions {
self.flag(raw::GIT_STATUS_OPT_NO_REFRESH, include)
}
pub fn update_index(&mut self, include: bool) -> &mut StatusOptions {
self.flag(raw::GIT_STATUS_OPT_UPDATE_INDEX, include)
}
#[allow(missing_docs)]
pub fn include_unreadable(&mut self, include: bool) -> &mut StatusOptions {
self.flag(raw::GIT_STATUS_OPT_INCLUDE_UNREADABLE, include)
}
#[allow(missing_docs)]
pub fn include_unreadable_as_untracked(&mut self, include: bool) -> &mut StatusOptions {
self.flag(raw::GIT_STATUS_OPT_INCLUDE_UNREADABLE_AS_UNTRACKED, include)
}
pub fn rename_threshold(&mut self, threshold: u16) -> &mut StatusOptions {
self.raw.rename_threshold = threshold;
self
}
pub unsafe fn raw(&mut self) -> *const raw::git_status_options {
self.raw.pathspec.strings = self.ptrs.as_ptr() as *mut _;
self.raw.pathspec.count = self.ptrs.len() as size_t;
&self.raw
}
}
impl<'repo> Statuses<'repo> {
pub fn get(&self, index: usize) -> Option<StatusEntry<'_>> {
unsafe {
let p = raw::git_status_byindex(self.raw, index as size_t);
Binding::from_raw_opt(p)
}
}
pub fn len(&self) -> usize {
unsafe { raw::git_status_list_entrycount(self.raw) as usize }
}
pub fn is_empty(&self) -> bool {
self.len() == 0
}
pub fn iter(&self) -> StatusIter<'_> {
StatusIter {
statuses: self,
range: 0..self.len(),
}
}
}
impl<'repo> Binding for Statuses<'repo> {
type Raw = *mut raw::git_status_list;
unsafe fn from_raw(raw: *mut raw::git_status_list) -> Statuses<'repo> {
Statuses {
raw,
_marker: marker::PhantomData,
}
}
fn raw(&self) -> *mut raw::git_status_list {
self.raw
}
}
impl<'repo> Drop for Statuses<'repo> {
fn drop(&mut self) {
unsafe {
raw::git_status_list_free(self.raw);
}
}
}
impl<'a> Iterator for StatusIter<'a> {
type Item = StatusEntry<'a>;
fn next(&mut self) -> Option<StatusEntry<'a>> {
self.range.next().and_then(|i| self.statuses.get(i))
}
fn size_hint(&self) -> (usize, Option<usize>) {
self.range.size_hint()
}
}
impl<'a> DoubleEndedIterator for StatusIter<'a> {
fn next_back(&mut self) -> Option<StatusEntry<'a>> {
self.range.next_back().and_then(|i| self.statuses.get(i))
}
}
impl<'a> FusedIterator for StatusIter<'a> {}
impl<'a> ExactSizeIterator for StatusIter<'a> {}
impl<'a> IntoIterator for &'a Statuses<'a> {
type Item = StatusEntry<'a>;
type IntoIter = StatusIter<'a>;
fn into_iter(self) -> Self::IntoIter {
self.iter()
}
}
impl<'statuses> StatusEntry<'statuses> {
pub fn path_bytes(&self) -> &[u8] {
unsafe {
if (*self.raw).head_to_index.is_null() {
crate::opt_bytes(self, (*(*self.raw).index_to_workdir).old_file.path)
} else {
crate::opt_bytes(self, (*(*self.raw).head_to_index).old_file.path)
}
.unwrap()
}
}
pub fn path(&self) -> Option<&str> {
str::from_utf8(self.path_bytes()).ok()
}
pub fn status(&self) -> Status {
Status::from_bits_truncate(unsafe { (*self.raw).status as u32 })
}
pub fn head_to_index(&self) -> Option<DiffDelta<'statuses>> {
unsafe { Binding::from_raw_opt((*self.raw).head_to_index) }
}
pub fn index_to_workdir(&self) -> Option<DiffDelta<'statuses>> {
unsafe { Binding::from_raw_opt((*self.raw).index_to_workdir) }
}
}
impl<'statuses> Binding for StatusEntry<'statuses> {
type Raw = *const raw::git_status_entry;
unsafe fn from_raw(raw: *const raw::git_status_entry) -> StatusEntry<'statuses> {
StatusEntry {
raw,
_marker: marker::PhantomData,
}
}
fn raw(&self) -> *const raw::git_status_entry {
self.raw
}
}
#[cfg(test)]
mod tests {
use super::StatusOptions;
use std::fs::File;
use std::io::prelude::*;
use std::path::Path;
#[test]
fn smoke() {
let (td, repo) = crate::test::repo_init();
assert_eq!(repo.statuses(None).unwrap().len(), 0);
File::create(&td.path().join("foo")).unwrap();
let statuses = repo.statuses(None).unwrap();
assert_eq!(statuses.iter().count(), 1);
let status = statuses.iter().next().unwrap();
assert_eq!(status.path(), Some("foo"));
assert!(status.status().contains(crate::Status::WT_NEW));
assert!(!status.status().contains(crate::Status::INDEX_NEW));
assert!(status.head_to_index().is_none());
let diff = status.index_to_workdir().unwrap();
assert_eq!(diff.old_file().path_bytes().unwrap(), b"foo");
assert_eq!(diff.new_file().path_bytes().unwrap(), b"foo");
}
#[test]
fn filter() {
let (td, repo) = crate::test::repo_init();
t!(File::create(&td.path().join("foo")));
t!(File::create(&td.path().join("bar")));
let mut opts = StatusOptions::new();
opts.include_untracked(true).pathspec("foo");
let statuses = t!(repo.statuses(Some(&mut opts)));
assert_eq!(statuses.iter().count(), 1);
let status = statuses.iter().next().unwrap();
assert_eq!(status.path(), Some("foo"));
}
#[test]
fn gitignore() {
let (td, repo) = crate::test::repo_init();
t!(t!(File::create(td.path().join(".gitignore"))).write_all(b"foo\n"));
assert!(!t!(repo.status_should_ignore(Path::new("bar"))));
assert!(t!(repo.status_should_ignore(Path::new("foo"))));
}
#[test]
fn status_file() {
let (td, repo) = crate::test::repo_init();
assert!(repo.status_file(Path::new("foo")).is_err());
if cfg!(windows) {
assert!(repo.status_file(Path::new("bar\\foo.txt")).is_err());
}
t!(File::create(td.path().join("foo")));
if cfg!(windows) {
t!(::std::fs::create_dir_all(td.path().join("bar")));
t!(File::create(td.path().join("bar").join("foo.txt")));
}
let status = t!(repo.status_file(Path::new("foo")));
assert!(status.contains(crate::Status::WT_NEW));
if cfg!(windows) {
let status = t!(repo.status_file(Path::new("bar\\foo.txt")));
assert!(status.contains(crate::Status::WT_NEW));
}
}
}