cowstr 1.0.0-beta2

use constptr::ConstPtr;
use std::borrow::Borrow;
use std::fmt;
use std::ops;
use std::str::FromStr;

use crate::*;

/// Arbitrary immutable text as span from some shared string. `SubStr` holding a reference to
/// the `CowStr` they lie within. This removes the need to pass lifetimes around as memory
/// become reference counted.
#[derive(Debug, Clone)]
pub struct SubStr {
    string: CowStr,
    substr: ConstPtr<str>,
}

// `SubStr` are always immutable, thus the can be Send and Sync.
unsafe impl Send for SubStr {}
unsafe impl Sync for SubStr {}

/// A constant for an always empty `SubStr`.
pub const EMPTY_SUBSTR: SubStr = SubStr::from_static("");

impl SubStr {
    /// Create a `SubStr` that spans a complete `CowStr`.
    #[doc(hidden)]
    #[deprecated = "use SubStr::from()"]
    #[mutants::skip]
    #[must_use]
    #[inline]
    pub fn new(from: &CowStr) -> SubStr {
        SubStr {
            string: from.clone(),
            substr: ConstPtr::from(&from[..]),
        }
    }

    /// Create and `SubStr` from a `&str` that must be contained an initial `CowStr`.  This is
    /// useful when parsing or splitting a &str that is obtained from a `CowStr`. See the
    /// `from_raw_parts()` method for a unsafe/unchecked variant.
    ///
    /// # Panics
    ///
    /// `substr` is not within `from`.
    ///
    /// # Example
    ///
    /// ```
    /// # use cowstr::*;
    /// let origin = CowStr::from("test string");
    /// let (left, right) = origin.split_once(' ').unwrap();
    /// let left = SubStr::from_contained_str(&origin, left);
    /// let right = SubStr::from_contained_str(&origin, right);
    /// assert_eq!(left, "test");
    /// assert_eq!(right, "string");
    /// ```
    #[inline]
    #[must_use]
    pub fn from_contained_str(from: &CowStr, substr: &str) -> SubStr {
        // We need to check only for the first character, there is no way one can safely
        // construct a &str that spans past the end of a original CowStr
        assert!(
            from.as_bytes().as_ptr_range().contains(&substr.as_ptr()),
            "`substr` is not part of `from`"
        );
        unsafe { Self::from_raw_parts(from.clone(), substr) }
    }

    /// Create and `SubStr` as span of a `CowStr`.
    ///
    /// # Panics
    ///
    /// The range is wider than `from` or does not lie on utf-8 character boundaries.
    ///
    /// # Example
    ///
    /// ```
    /// # use cowstr::*;
    /// let origin = CowStr::from("this is a test string");
    /// let substr = SubStr::from_range(&origin, 10..14).unwrap();
    /// assert_eq!(substr, "test");
    /// ```
    pub fn from_range<R>(from: &CowStr, range: R) -> Result<SubStr, Error>
    where
        R: std::slice::SliceIndex<str, Output = str> + Clone,
        Self: ops::Index<R, Output = str>,
    {
        if let Some(substr) = from.get(range) {
            Ok(SubStr {
                string: from.clone(),
                // Safety: we got a valid 'Some(substr)' above.
                substr: unsafe { ConstPtr::new_unchecked(substr) },
            })
        } else {
            Err(Error::Range)
        }
    }

    #[doc(hidden)]
    #[deprecated = "use SubStr::from_range()"]
    #[mutants::skip]
    #[must_use]
    #[inline]
    pub fn new_range(from: &CowStr, range: ops::Range<usize>) -> Result<SubStr, Error> {
        Self::from_range(from, range)
    }

    /// Create a `SubStr` as range from an existing `SubStr`.
    ///
    /// # Panics
    ///
    /// The range is wider than `from` or does not lie on utf-8 character boundaries.
    ///
    /// # Example
    ///
    /// ```
    /// # use cowstr::*;
    /// let origin = SubStr::from("this is a test string");
    /// let substr = SubStr::sub_range(&origin, 10..14).unwrap();
    /// assert_eq!(substr, "test");
    /// ```
    pub fn sub_range<R>(&self, range: R) -> Result<SubStr, Error>
    where
        R: std::slice::SliceIndex<str, Output = str> + Clone,
        Self: ops::Index<R, Output = str>,
    {
        if let Some(substr) = unsafe { self.substr.as_ref() }.get(range) {
            Ok(SubStr {
                string: self.string.clone(),
                // Safety: we got a valid 'Some(substr)' above.
                substr: unsafe { ConstPtr::new_unchecked(substr) },
            })
        } else {
            Err(Error::Range)
        }
    }

    /// Create a `SubStr` that spans a complete `'static str`.
    ///
    /// # Example
    ///
    /// ```
    /// # use cowstr::*;
    /// let static_substr = SubStr::from_static("test string");
    /// assert_eq!(static_substr, "test string");
    /// ```
    #[must_use]
    #[inline]
    pub const fn from_static(from: &'static str) -> SubStr {
        SubStr {
            string: CowStr::from_static(from),
            // Safety: 'from' is a valid reference.
            substr: unsafe { ConstPtr::new_unchecked(from) },
        }
    }

    /// Returns `Ok(&'static str)` when the underlying string has static lifetime and
    /// `Err(&'self str)` when it is dynamically allocated.
    ///
    /// # Example
    ///
    /// ```
    /// # use cowstr::*;
    /// let static_substr = SubStr::from_static("test string");
    /// assert_eq!(static_substr.deref_static(), Ok("test string"));
    ///
    /// let dynamic_substr = SubStr::from("test string");
    /// assert_eq!(dynamic_substr.deref_static(), Err("test string"));
    /// ```
    #[inline]
    pub fn deref_static(&self) -> Result<&'static str, &str> {
        match self.string.deref_static() {
            Ok(_) => Ok(unsafe { self.substr.as_ref() }),
            Err(_) => Err(unsafe { self.substr.as_ref() }),
        }
    }

    /// Get a reference to the original `CowStr` from which this `SubStr` is constructed.
    #[inline]
    #[must_use]
    pub fn origin(&self) -> &CowStr {
        &self.string
    }

    /// Returns 'true' when two `SubStrs` share the same original `CowStr`.
    #[inline]
    #[must_use]
    pub fn same_origin(&self, other: &Self) -> bool {
        self.origin().is_same_as(other.origin())
    }

    /// Create a `SubStr` from its raw components.
    ///
    /// # Safety
    ///
    /// `substr` must be slice inside of `from`.
    #[inline]
    #[must_use]
    pub unsafe fn from_raw_parts(from: CowStr, substr: *const str) -> SubStr {
        debug_assert!(
            from.as_bytes()
                .as_ptr_range()
                .contains(&substr.cast::<u8>()),
            "`substr` is not part of `from`"
        );
        SubStr {
            string: from,
            substr: ConstPtr::new_unchecked(substr),
        }
    }

    /// Deconstructs the `Substr` into its raw parts. Note that the returned `ConstPtr<str>`
    /// will only be valid as long the owning `CowStr` is not mutated or dropped. The only
    /// exception here are the `try_push_*()` methods which neither reallocate nor mutate the
    /// slice that is referenced by the `ConstPtr<str>`.
    #[inline]
    #[must_use]
    pub fn into_raw_parts(self) -> (CowStr, *const str) {
        (self.string, self.substr.as_ptr())
    }
}

impl fmt::Display for SubStr {
    #[inline]
    #[mutants::skip] /* we just pretend it works */
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt::Display::fmt(&**self, f)
    }
}

impl ops::Deref for SubStr {
    type Target = str;

    #[inline]
    fn deref(&self) -> &Self::Target {
        // Safety: substr is always valid
        unsafe { self.substr.as_ref() }
    }
}

impl From<&str> for SubStr {
    #[inline]
    fn from(s: &str) -> Self {
        SubStr::from(CowStr::from(s))
    }
}

impl From<&mut str> for SubStr {
    #[inline]
    fn from(s: &mut str) -> Self {
        SubStr::from(CowStr::from(s))
    }
}

impl From<CowStr> for SubStr {
    #[inline]
    fn from(cow: CowStr) -> Self {
        SubStr::from(&cow)
    }
}

impl From<&CowStr> for SubStr {
    #[inline]
    fn from(from: &CowStr) -> Self {
        SubStr {
            string: from.clone(),
            substr: ConstPtr::from(&from[..]),
        }
    }
}

impl From<String> for SubStr {
    #[inline]
    fn from(s: String) -> Self {
        SubStr::from(&*s)
    }
}

impl From<&String> for SubStr {
    #[inline]
    fn from(s: &String) -> Self {
        SubStr::from(&**s)
    }
}

impl From<char> for SubStr {
    #[inline]
    fn from(c: char) -> Self {
        SubStr::from(CowStr::from(c))
    }
}

#[test]
fn from() {
    assert_eq!(SubStr::from(String::from("foobar").as_mut_str()), "foobar");
    assert_eq!(SubStr::from(String::from("foobar")), "foobar");
    assert_eq!(SubStr::from(&String::from("foobar")), "foobar");
    assert_eq!(SubStr::from('x'), "x");
    let cowstr = SubStr::from("cowstr");
    assert_eq!(SubStr::from(cowstr), "cowstr");
    assert_eq!(SubStr::from(SubStr::from("cowstr")), "cowstr");
}

impl Eq for SubStr {}

impl ops::Index<ops::RangeFull> for SubStr {
    type Output = str;

    #[inline]
    fn index(&self, _index: ops::RangeFull) -> &str {
        &*self
    }
}

impl ops::Index<ops::Range<usize>> for SubStr {
    type Output = str;

    #[inline]
    fn index(&self, index: ops::Range<usize>) -> &str {
        &(**self)[index]
    }
}

impl ops::Index<ops::RangeFrom<usize>> for SubStr {
    type Output = str;

    #[inline]
    fn index(&self, index: ops::RangeFrom<usize>) -> &str {
        &(**self)[index]
    }
}

impl ops::Index<ops::RangeTo<usize>> for SubStr {
    type Output = str;

    #[inline]
    fn index(&self, index: ops::RangeTo<usize>) -> &str {
        &(**self)[index]
    }
}

impl ops::Index<ops::RangeInclusive<usize>> for SubStr {
    type Output = str;

    #[inline]
    fn index(&self, index: ops::RangeInclusive<usize>) -> &str {
        &(**self)[index]
    }
}

impl ops::Index<ops::RangeToInclusive<usize>> for SubStr {
    type Output = str;

    #[inline]
    fn index(&self, index: ops::RangeToInclusive<usize>) -> &str {
        &(**self)[index]
    }
}

#[test]
fn index() {
    let substr = SubStr::from("fööbär");

    assert_eq!(&substr[..], "fööbär");
    assert_eq!(&substr[5..8], "bä");
    assert_eq!(&substr[5..], "bär");
    assert_eq!(&substr[..6], "fööb");
    assert_eq!(&substr[5..=8], "bär");
    assert_eq!(&substr[..=4], "föö");
}

impl PartialEq for SubStr {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        **self == **other
    }
}

impl PartialEq<&SubStr> for SubStr {
    #[inline]
    fn eq(&self, other: &&SubStr) -> bool {
        **self == **other
    }
}

impl PartialEq<SubStr> for &SubStr {
    #[inline]
    fn eq(&self, other: &SubStr) -> bool {
        **self == **other
    }
}

impl PartialEq<&str> for SubStr {
    #[inline]
    fn eq(&self, other: &&str) -> bool {
        **self == **other
    }
}

impl PartialEq<SubStr> for &str {
    #[inline]
    fn eq(&self, other: &SubStr) -> bool {
        **self == **other
    }
}

impl PartialEq<CowStr> for &SubStr {
    #[inline]
    fn eq(&self, other: &CowStr) -> bool {
        **self == **other
    }
}

impl PartialEq<&SubStr> for CowStr {
    #[inline]
    fn eq(&self, other: &&SubStr) -> bool {
        **self == **other
    }
}

impl PartialEq<CowStr> for SubStr {
    #[inline]
    fn eq(&self, other: &CowStr) -> bool {
        **self == **other
    }
}

impl PartialEq<SubStr> for CowStr {
    #[inline]
    fn eq(&self, other: &SubStr) -> bool {
        **self == **other
    }
}

impl PartialEq<str> for SubStr {
    #[inline]
    fn eq(&self, other: &str) -> bool {
        **self == *other
    }
}

impl PartialEq<SubStr> for str {
    #[inline]
    fn eq(&self, other: &SubStr) -> bool {
        *self == **other
    }
}

#[test]
fn partial_eq() {
    let foo = SubStr::from("foo");
    let foo2 = SubStr::from("foo");
    let bar = SubStr::from("bar");
    let cowfoo = CowStr::from("foo");
    let cowbar = CowStr::from("bar");

    assert_partial_eq!(foo, foo2, bar);
    assert_partial_eq!(foo, "foo", "bar");
    assert_partial_eq!(&foo, foo2, bar);
    assert_partial_eq!(&foo, "foo", "bar");
    assert_partial_eq!(foo, cowfoo, cowbar);
    assert_partial_eq!(&foo, cowfoo, cowbar);
}

impl Ord for SubStr {
    #[inline]
    fn cmp(&self, other: &SubStr) -> std::cmp::Ordering {
        (**self).cmp(other)
    }
}

impl PartialOrd for SubStr {
    #[mutants::skip] /* infallible, cant be coverage tested  */
    #[inline]
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        (**self).partial_cmp(other)
    }
}

impl PartialOrd<&str> for SubStr {
    #[mutants::skip] /* infallible, cant be coverage tested  */
    #[inline]
    fn partial_cmp(&self, other: &&str) -> Option<std::cmp::Ordering> {
        (**self).partial_cmp(*other)
    }
}

impl PartialOrd<SubStr> for &str {
    #[mutants::skip] /* infallible, cant be coverage tested  */
    #[inline]
    fn partial_cmp(&self, other: &SubStr) -> Option<std::cmp::Ordering> {
        (**self).partial_cmp(other)
    }
}

impl PartialOrd<CowStr> for SubStr {
    #[mutants::skip] /* infallible, cant be coverage tested  */
    #[inline]
    fn partial_cmp(&self, other: &CowStr) -> Option<std::cmp::Ordering> {
        (**self).partial_cmp(other)
    }
}

impl PartialOrd<SubStr> for CowStr {
    #[mutants::skip] /* infallible, cant be coverage tested  */
    #[inline]
    fn partial_cmp(&self, other: &SubStr) -> Option<std::cmp::Ordering> {
        (**self).partial_cmp(other)
    }
}

#[test]
fn partial_ord() {
    let a = SubStr::from("a");
    let b = SubStr::from("b");
    let c = SubStr::from("c");
    let cowa = CowStr::from("a");
    let cowc = CowStr::from("c");
    assert_partial_ord!(a, b, c);
    assert_partial_ord!("a", b, "c");
    assert_partial_ord!(cowa, b, cowc);
}

impl FromStr for SubStr {
    type Err = core::convert::Infallible;
    #[inline]
    fn from_str(s: &str) -> Result<SubStr, Self::Err> {
        Ok(SubStr::from(s))
    }
}

impl AsRef<str> for SubStr {
    #[inline]
    fn as_ref(&self) -> &str {
        self
    }
}

impl AsRef<[u8]> for SubStr {
    #[inline]
    fn as_ref(&self) -> &[u8] {
        self.as_bytes()
    }
}

#[test]
fn as_ref() {
    let foo = SubStr::from("foo");
    let bar = SubStr::from("bar");
    assert_eq!(<substr::SubStr as AsRef<str>>::as_ref(&foo), "foo");
    assert_ne!(<substr::SubStr as AsRef<str>>::as_ref(&bar), "foo");
    assert_eq!(
        <substr::SubStr as AsRef<[u8]>>::as_ref(&foo),
        [102, 111, 111]
    );
    assert_ne!(<substr::SubStr as AsRef<[u8]>>::as_ref(&bar), [1, 2, 3]);
}

impl Borrow<str> for SubStr {
    #[inline]
    fn borrow(&self) -> &str {
        self
    }
}

#[test]
fn borrow() {
    let foo = SubStr::from("foo");
    let bar = SubStr::from("bar");
    assert_eq!(<substr::SubStr as Borrow<str>>::borrow(&foo), "foo");
    assert_ne!(<substr::SubStr as Borrow<str>>::borrow(&bar), "foo");
}

/// A trait for converting a value to a `SubStr`.
///
/// This trait is automatically implemented for any type which implements the
/// [`Display`] trait. As such, `ToSubStr` shouldn't be implemented directly:
/// [`Display`] should be implemented instead, and you get the `ToSubStr`
/// implementation for free.
///
/// [`Display`]: fmt::Display
pub trait ToSubStr {
    /// Converts the given value to a `SubStr`.
    ///
    /// # Examples
    ///
    /// ```
    /// use cowstr::ToSubStr;
    ///
    /// let i = 5;
    /// assert_eq!(i.to_substr(), "5");
    /// ```
    fn to_substr(&self) -> SubStr;
}

// PLANNED: specialization like stdlib does
impl<T: fmt::Display + ?Sized> ToSubStr for T {
    #[inline]
    fn to_substr(&self) -> SubStr {
        let mut buf = CowStr::new();
        fmt::write(&mut buf, format_args!("{}", self)).unwrap();
        SubStr::from(buf)
    }
}

#[test]
fn empty() {
    assert_eq!(EMPTY_SUBSTR, "");
}

#[test]
fn from_ref() {
    let origin = CowStr::from("test string");
    let substr = SubStr::from(&origin);
    assert_eq!(substr, "test string");
}

#[test]
#[should_panic]
fn from_panic() {
    let origin = CowStr::from("test string");
    let _substr = SubStr::from_range(&origin, 10..100).unwrap();
}

#[test]
fn deref_static_static() {
    let static_origin = CowStr::from_static("test string");
    let static_substr = SubStr::from(&static_origin);
    assert_eq!(static_substr.deref_static(), Ok("test string"));
}

#[test]
fn deref_static_dynamic() {
    let dynamic_origin = CowStr::from("test string");
    let dynamic_substr = SubStr::from(&dynamic_origin);
    assert_eq!(dynamic_substr.deref_static(), Err("test string"));
}

#[test]
fn same_origin() {
    let origin = CowStr::from("foobar");
    let sub1 = SubStr::from_range(&origin, 0..3).unwrap();
    let sub2 = SubStr::from_range(&origin, 3..6).unwrap();
    assert_eq!(sub1, "foo");
    assert_eq!(sub2, "bar");
    assert!(sub1.same_origin(&sub2));
}

#[test]
fn different_origin() {
    let sub1 = SubStr::from("foo");
    let sub2 = SubStr::from("bar");
    assert!(!sub1.same_origin(&sub2));
}

#[test]
fn clone_increments_refcount() {
    let sub1 = SubStr::from("foo");
    assert_eq!(sub1.origin().strong_count().unwrap().get(), 1);
    let sub2 = sub1.clone();
    assert!(sub1.same_origin(&sub2));
    assert_eq!(sub1.origin().strong_count().unwrap().get(), 2);
    assert_eq!(sub2.origin().strong_count().unwrap().get(), 2);
}