1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

use std::fmt::{Display, Formatter, Result as FmtResult};

/// Configures a paginated listing.
pub struct ListingOptions {
    /// The maximum amount of posts to fetch in one request.
    pub batch: u8,
    /// See `ListingAnchor` for explanation of this property.
    pub anchor: ListingAnchor,
}

impl Display for ListingOptions {
    fn fmt(&self, f: &mut Formatter) -> FmtResult {
        write!(f, "limit={}", self.batch)
    }
}

impl ListingOptions {
    /// Provides the default options (25 posts per page, starts at first post in listing). If
    /// you are unsure, this will act like the default display options on Reddit.
    pub fn default() -> ListingOptions {
        ListingOptions {
            batch: 25,
            anchor: ListingAnchor::None,
        }
    }
}

/// Used to 'anchor' the pagination so you can get all posts before/after a post.
pub enum ListingAnchor {
    /// Gets all items after the specified one, e.g. gets posts older than the specified post in
    /// the new queue.
    After(String),
    /// Gets all items before the specified one, e.g. gets posts higher than the specified one in
    /// the top queue.
    Before(String),
    /// Use no anchor.
    None,
}

impl Display for ListingAnchor {
    fn fmt(&self, f: &mut Formatter) -> FmtResult {
        match *self {
            ListingAnchor::Before(ref pos) => write!(f, "before={}", pos),
            ListingAnchor::After(ref pos) => write!(f, "after={}", pos),
            ListingAnchor::None => Ok(()),
        }
    }
}

/// Used for filtering by time in the top and controversial queues.
#[allow(missing_docs)]
pub enum TimeFilter {
    Hour,
    Day,
    Week,
    Month,
    Year,
    AllTime,
}

impl Display for TimeFilter {
    fn fmt(&self, f: &mut Formatter) -> FmtResult {
        let s = match *self {
            TimeFilter::Hour => "hour",
            TimeFilter::Day => "day",
            TimeFilter::Week => "week",
            TimeFilter::Month => "month",
            TimeFilter::Year => "year",
            TimeFilter::AllTime => "all",
        };
        write!(f, "&t={}", s)
    }
}

/// Options used when creating a link post. See `structures::subreddit` for examples of usage.
pub struct LinkPost {
    /// The title of the link post to create
    pub title: String,
    /// The URL of the link to post. If this has been posted before, you **must** mark this as a
    /// resubmission or the API will raise an error. See `LinkPost::resubmit()` for an example.
    pub link: String,
    /// True if resubmitting this link is intended.
    pub resubmit: bool,
}

impl LinkPost {
    /// Creates a new `LinkPost` structure that contains the options for a link post.
    /// The post is not actually sent at this point.
    pub fn new(title: &str, link: &str) -> LinkPost {
        LinkPost {
            title: title.to_owned(),
            link: link.to_owned(),
            resubmit: false,
        }
    }

    /// Marks this post as a resubmission, so the API will accept it even if it has been submitted
    /// in this subreddit before.
    /// # Examples
    /// ```
    /// use rawr::options::LinkPost;
    /// let post = LinkPost::new("Look at this!", "http://example.com/foo").resubmit();
    /// ```
    pub fn resubmit(mut self) -> LinkPost {
        self.resubmit = true;
        self
    }
}

/// Options used when creating a self post. See `structures::subreddit` for examples of usage.
pub struct SelfPost {
    /// The title of the link post to create
    pub title: String,
    /// The markdown post body.
    pub text: String,
}

impl SelfPost {
    /// Creates a new `SelfPost` object. The post will not be submitted until you use
    /// `Subreddit.submit_text()`.
    pub fn new(title: &str, text: &str) -> SelfPost {
        SelfPost {
            title: title.to_owned(),
            text: text.to_owned(),
        }
    }
}