Merge pull request #124 from madsmtm/bigger-foundation

Add more classes to `objc2-foundation`

Author: madsmtm

objc2-foundation/CHANGELOG.md

@@ -11,6 +11,18 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
   `NSArray`, which derefs to `NSObject`, which derefs to `Object`.
 
   This allows more ergonomic usage.
+* Implement `PartialOrd` and `Ord` for `NSString` and `NSRange`.
+* Added `NSString::has_prefix` and `NSString::has_suffix`.
+* Added `NSRange` methods `new`, `is_empty`, `contains` and `end`.
+* Added `NSThread` object.
+* Added `is_multi_threaded` and `is_main_thread` helper functions.
+* Added `NSProcessInfo` object.
+* Added `NSMutableData` methods `from_data`, `with_capacity` and `push`.
+* Added `io::Write` and `iter::Extend` implementation for `NSMutableData`.
+* Added `NSUUID` object.
+* Added `NSMutableString` object.
+* Added basic `NSAttributedString` object.
+* Added basic `NSMutableAttributedString` object.
 
 ### Changed
 * **BREAKING**: Removed the following helper traits in favor of inherent
@@ -32,6 +44,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
   - `INSCopying` (now `NSCopying`)
   - `INSMutableCopying` (now `NSMutableCopying`)
   - `INSFastEnumeration` (now `NSFastEnumeration`)
+* **BREAKING**: Renamed `NSMutableData::append` to `extend_from_slice`.
 
 
 ## 0.2.0-alpha.4 - 2022-01-03

objc2-foundation/src/attributed_string.rs

@@ -0,0 +1,165 @@
+use core::ptr::NonNull;
+
+use objc2::msg_send;
+use objc2::rc::{DefaultId, Id, Shared};
+use objc2::runtime::Object;
+
+use crate::{
+    NSCopying, NSDictionary, NSMutableAttributedString, NSMutableCopying, NSObject, NSString,
+};
+
+object! {
+    /// A string that has associated attributes for portions of its text.
+    ///
+    /// Examples of attributes could be: Visual style, hyperlinks, or
+    /// accessibility data.
+    ///
+    /// Conceptually, each UTF-16 code unit in an attributed string has its
+    /// own collection of attributes - most often though
+    ///
+    /// Only the most basic functionality is defined here, the `AppKit`
+    /// framework contains most of the extension methods.
+    ///
+    /// See [Apple's documentation](https://developer.apple.com/documentation/foundation/nsattributedstring?language=objc).
+    unsafe pub struct NSAttributedString: NSObject;
+}
+
+// TODO: SAFETY
+unsafe impl Sync for NSAttributedString {}
+unsafe impl Send for NSAttributedString {}
+
+/// Attributes that you can apply to text in an attributed string.
+pub type NSAttributedStringKey = NSString;
+
+/// Creating attributed strings.
+impl NSAttributedString {
+    unsafe_def_fn! {
+        /// Construct an empty attributed string.
+        pub fn new -> Shared;
+    }
+
+    /// Creates a new attributed string from the given string and attributes.
+    ///
+    /// The attributes are associated with every UTF-16 code unit in the
+    /// string.
+    #[doc(alias = "initWithString:")]
+    pub fn new_with_attributes(
+        string: &NSString,
+        // TODO: Mutability of the dictionary should be (Shared, Shared)
+        attributes: &NSDictionary<NSAttributedStringKey, Object>,
+    ) -> Id<Self, Shared> {
+        unsafe {
+            let obj: *mut Self = msg_send![Self::class(), alloc];
+            let obj: *mut Self = msg_send![obj, initWithString: string, attributes: attributes];
+            Id::new(NonNull::new_unchecked(obj))
+        }
+    }
+
+    /// Creates a new attributed string without any attributes.
+    #[doc(alias = "initWithString:")]
+    pub fn from_nsstring(string: &NSString) -> Id<Self, Shared> {
+        unsafe {
+            let obj: *mut Self = msg_send![Self::class(), alloc];
+            let obj: *mut Self = msg_send![obj, initWithString: string];
+            Id::new(NonNull::new_unchecked(obj))
+        }
+    }
+}
+
+/// Querying.
+impl NSAttributedString {
+    // TODO: Lifetimes?
+    pub fn string(&self) -> &NSString {
+        unsafe { msg_send![self, string] }
+    }
+
+    /// Alias for `self.string().len_utf16()`.
+    #[doc(alias = "length")]
+    #[allow(unused)]
+    // TODO: Finish this
+    fn len_utf16(&self) -> usize {
+        unsafe { msg_send![self, length] }
+    }
+
+    // /// TODO
+    // ///
+    // /// See [Apple's documentation on Effective and Maximal Ranges][doc].
+    // ///
+    // /// [doc]: https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/AttributedStrings/Tasks/AccessingAttrs.html#//apple_ref/doc/uid/20000161-SW2
+    // #[doc(alias = "attributesAtIndex:effectiveRange:")]
+    // pub fn attributes_in_effective_range(
+    //     &self,
+    //     index: usize,
+    //     range: Range<usize>,
+    // ) -> Id<Self, Shared> {
+    //     let range = NSRange::from(range);
+    //     todo!()
+    // }
+    //
+    // attributesAtIndex:longestEffectiveRange:inRange:
+
+    // TODO: attributedSubstringFromRange:
+    // TODO: enumerateAttributesInRange:options:usingBlock:
+}
+
+impl DefaultId for NSAttributedString {
+    type Ownership = Shared;
+
+    #[inline]
+    fn default_id() -> Id<Self, Self::Ownership> {
+        Self::new()
+    }
+}
+
+unsafe impl NSCopying for NSAttributedString {
+    type Ownership = Shared;
+    type Output = NSAttributedString;
+}
+
+unsafe impl NSMutableCopying for NSAttributedString {
+    type Output = NSMutableAttributedString;
+}
+
+#[cfg(test)]
+mod tests {
+    use alloc::string::ToString;
+    use objc2::rc::autoreleasepool;
+
+    use super::*;
+
+    #[test]
+    fn test_new() {
+        let s = NSAttributedString::new();
+        assert_eq!(&s.string().to_string(), "");
+    }
+
+    #[test]
+    fn test_string_bound_to_attributed() {
+        let attr_s = {
+            let source = NSString::from_str("Hello world!");
+            NSAttributedString::from_nsstring(&source)
+        };
+        let s = autoreleasepool(|_| attr_s.string());
+        assert_eq!(s.len(), 12);
+    }
+
+    #[test]
+    fn test_from_nsstring() {
+        let s = NSAttributedString::from_nsstring(&NSString::from_str("abc"));
+        assert_eq!(&s.string().to_string(), "abc");
+    }
+
+    #[test]
+    fn test_copy() {
+        let s1 = NSAttributedString::from_nsstring(&NSString::from_str("abc"));
+        let s2 = s1.copy();
+        // NSAttributedString performs this optimization in GNUStep's runtime,
+        // but not in Apple's; so we don't test for it!
+        // assert_eq!(s1.as_ptr(), s2.as_ptr());
+        assert!(s2.is_kind_of(NSAttributedString::class()));
+
+        let s3 = s1.mutable_copy();
+        assert_ne!(s1.as_ptr(), s3.as_ptr() as *mut NSAttributedString);
+        assert!(s3.is_kind_of(NSMutableAttributedString::class()));
+    }
+}

objc2-foundation/src/comparison_result.rs

@@ -2,15 +2,22 @@ use core::cmp::Ordering;
 
 use objc2::{Encode, Encoding, RefEncode};
 
+/// Constants that indicate sort order.
+///
+/// See [Apple's documentation](https://developer.apple.com/documentation/foundation/nscomparisonresult?language=objc).
 #[repr(isize)] // NSInteger
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub enum NSComparisonResult {
+    /// The left operand is smaller than the right operand.
     Ascending = -1,
+    /// The two operands are equal.
     Same = 0,
+    /// The left operand is greater than the right operand.
     Descending = 1,
 }
 
 impl Default for NSComparisonResult {
+    #[inline]
     fn default() -> Self {
         Self::Same
     }
@@ -25,6 +32,7 @@ unsafe impl RefEncode for NSComparisonResult {
 }
 
 impl From<Ordering> for NSComparisonResult {
+    #[inline]
     fn from(order: Ordering) -> Self {
         match order {
             Ordering::Less => Self::Ascending,
@@ -35,6 +43,7 @@ impl From<Ordering> for NSComparisonResult {
 }
 
 impl From<NSComparisonResult> for Ordering {
+    #[inline]
     fn from(comparison_result: NSComparisonResult) -> Self {
         match comparison_result {
             NSComparisonResult::Ascending => Self::Less,