redd 0.8.8 → 0.9.0.pre.1

data/lib/redd/models/access.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'basic_model'
+require_relative 'model'
 
 module Redd
   module Models
@@ -8,35 +8,47 @@ module Redd
     # @note This model also supports an additional key, called `:created_at` which is a UNIX time
     #   representing the time the access was created. The default value is the time the object was
     #   initialized.
-    class Access < BasicModel
+    class Access < Model
       # Create a non-lazily initialized Access.
-      # @param client [Object] (deprecated) the client to create the object with
-      # @param attributes [Hash] the Access's attributes
+      # @param attributes [Hash] the access's attributes
       # @example
       #   access = Redd::Models::Access.new(access_token: ...)
-      def initialize(client = nil, attributes = {})
-        if client.is_a?(Hash)
-          super(nil, client)
-        else
-          super(client, attributes)
-        end
+      def initialize(attributes = {})
+        super(nil, attributes)
+        @creation_time = Time.now
       end
 
+      # Whether the access has expired.
+      # @param grace_period [Integer] the grace period where the model expires early
+      # @return [Boolean] whether the access has expired
       def expired?(grace_period = 60)
-        # We're not sure, so we just assume it hasn't expired.
-        return false unless @attributes[:expires_in]
-        Time.now.to_i > @attributes[:created_at] + (@attributes[:expires_in] - grace_period)
+        Time.now > read_attribute(:created_at) + read_attribute(:expires_in) - grace_period
       end
 
+      # @return [Boolean] whether the access can be refreshed
       def permanent?
-        !@attributes[:refresh_token].nil?
+        read_attribute(:refresh_token).nil?
       end
 
-      private
+      # @!attribute [r] access_token
+      #   @return [String] the access token
+      property :access_token
 
-      def after_initialize
-        @attributes[:created_at] ||= Time.now.to_i
-      end
+      # @!attribute [r] refresh_token
+      #   @return [String] the (optional) refresh token
+      property :refresh_token, :nil
+
+      # @!attribute [r] expires_in
+      #   @return [Integer] the number of seconds before the access expires
+      property :expires_in
+
+      # @!attribute [r] created_at
+      #   @return [Time] the time the access was created
+      property :created_at, default: ->() { @creation_time }
+
+      # @!attribute [r] scope
+      #   @return [Array<String>] the scopes that the user is allowed to access
+      property :scope, with: ->(scope) { scope.split(' ') }
     end
   end
 end

data/lib/redd/models/comment.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
 
-require_relative 'lazy_model'
+require_relative 'model'
 require_relative 'gildable'
 require_relative 'inboxable'
 require_relative 'moderatable'
 require_relative 'postable'
 require_relative 'replyable'
+require_relative 'reportable'
 
 require_relative 'listing'
 require_relative 'subreddit'
@@ -14,47 +15,204 @@ require_relative 'user'
 module Redd
   module Models
     # A comment.
-    class Comment < LazyModel
+    class Comment < Model
       include Gildable
       include Inboxable
       include Moderatable
       include Postable
       include Replyable
+      include Reportable
 
-      # Create a Comment from its fullname.
-      # @param client [APIClient] the api client to initialize the object with
-      # @param id [String] the fullname
-      # @return [Comment]
-      def self.from_id(client, id)
-        new(client, name: id)
-      end
+      # @!attribute [r] subreddit_id
+      #   @return [String] the subreddit fullname
+      property :subreddit_id
 
-      private
+      # @!attribute [r] approved_at
+      #   @return [Time, nil] the time when the comment was approved
+      property :approved_at, from: :approved_at_utc, with: ->(t) { Time.at(t) if t }
 
-      def after_initialize
-        @attributes[:replies] =
-          if @attributes[:replies].is_a?(Hash)
-            @client.unmarshal(@attributes[:replies])
-          else
-            Models::Listing.new(@client, children: [], after: nil, before: nil)
-          end
-        @attributes[:author] = User.from_id(@client, @attributes.fetch(:author))
-        @attributes[:subreddit] = Subreddit.from_id(@client, @attributes.fetch(:subreddit))
-      end
+      # @!attribute [r] banned_by
+      #   @return [String] the user (?) that banned this comment
+      property :banned_by
+
+      # @!attribute [r] removal_reason
+      #   @return [String, nil] the reason for comment removal
+      property :removal_reason
+
+      # @!attribute [r] link
+      #   @return [Submission] the link that the comment was posted to
+      property :link, from: :link_id, with: ->(id) { Submission.new(client, name: id) }
+
+      # @!attribute [r] upvoted?
+      #   @return [Boolean, nil] whether the user liked/disliked this comment
+      property :upvoted?, from: :likes
+
+      # @!attribute [r] replies
+      #   @return [Listing<Comment>] the comment replies
+      property :replies, with: ->(l) { Listing.new(client, l[:data]) if l.is_a?(Hash) }
+
+      # @!attribute [r] user_reports
+      #   @return [Array<String>] user reports
+      property :user_reports
+
+      # @!attribute [r] saved?
+      #   @return [Boolean] whether the submission was saved by the logged-in user
+      property :saved?, from: :saved
+
+      # @!attribute [r] id
+      #   @return [String] the comment id
+      property :id
+
+      # @!attribute [r] banned_at
+      #   @return [Time, nil] the time when the comment was banned
+      property :banned_at, from: :banned_at_utc, with: ->(t) { Time.at(t) if t }
+
+      # @!attribute [r] gilded
+      #   @return [Integer] the number of times the comment was gilded
+      property :gilded
+
+      # @!attribute [r] archived?
+      #   @return [Boolean] whether this comment was archived
+      property :archived?, from: :archived
+
+      # @!attribute [r] report_reasons
+      #   @return [Array<String>] report reasons
+      property :report_reasons
+
+      # @!attribute [r] author
+      #   @return [User] the comment author
+      property :author, with: ->(name) { User.new(client, name: name) }
+
+      # @!attribute [r] can_mod_post?
+      #   @return [Boolean] whether the logged-in user can mod post
+      property :can_mod_post?, from: :can_mod_post
+
+      # @!attribute [r] ups
+      #   @return [Integer] the comment upvotes
+      #   @deprecated use {#score} instead
+      property :ups
+
+      # @!attribute [r] downs
+      #   @return [Integer] the comment downvotes
+      #   @deprecated is always 0; use {#score} instead
+      property :downs
+
+      # @!attribute [r] parent
+      #   @return [Comment, Submission] the comment parent
+      property :parent,
+               from: :parent_id,
+               with: ->(id) { Session.new(client).from_fullnames(id).first }
+
+      # @!attribute [r] score
+      #   @return [Integer] the comment score
+      property :score
+
+      # @!attribute [r] approved_by
+      #   @return [String] the user that approved the comment
+      property :approved_by
+
+      # @!attribute [r] body
+      #   @return [String] the markdown comment body
+      property :body
+
+      # @!attribute [r] body_html
+      #   @return [String] the html-rendered version of the body
+      property :body_html
+
+      # @!attribute [r] edited_at
+      #   @return [Time, nil] the time when the comment was edited
+      property :edited_at, from: :edited, with: ->(t) { Time.at(t) if t }
+
+      # @!attribute [r] author_flair_css_class
+      #   @return [String] the author flair css class
+      property :author_flair_css_class
+
+      # @!attribute [r] collapsed?
+      #   @return [Boolean] whether the comment was collapsed
+      property :collapsed?, from: :collapsed
+
+      # @!attribute [r] submitter?
+      #   @return [Boolean] whether the comment author is the link submitter
+      property :submitter?, from: :is_submitter
+
+      # @!attribute [r] collapsed_reason
+      #   @return [String] the reason for collapse (?)
+      property :collapsed_reason
+
+      # @!attribute [r] stickied?
+      #   @return [Boolean] whether the comment was stickied
+      property :stickied?, from: :stickied
+
+      # @!attribute [r] can_gild?
+      #   @return [Boolean] whether the comment is gildable
+      property :can_gild?, from: :can_gild
+
+      # @!attribute [r] subreddit
+      #   @return [Subreddit] the comment's subreddit
+      property :subreddit, with: ->(n) { Subreddit.new(client, display_name: n) }
+
+      # @!attribute [r] score_hidden
+      #   @return [Boolean] whether the comment score is hidden 
+      property :score_hidden?, from: :score_hidden
+
+      # @!attribute [r] subreddit_type
+      #   @return [String] subreddit type
+      property :subreddit_type
+
+      # @!attribute [r] name
+      #   @return [String] the comment fullname
+      property :name
+
+      # @!attribute [r] author_flair_text
+      #   @return [String] the author flair text
+      property :author_flair_text
+
+      # @!attribute [r] created_at
+      #   @return [String] the time when the model was created
+      property :created_at, from: :created_utc, with: ->(t) { Time.at(t) }
+
+      # @!attribute [r] subreddit_name_prefixed
+      #   @return [String] the subreddit name, prefixed with "r/"
+      property :subreddit_name_prefixed
+
+      # @!attribute [r] controversiality
+      #   @return [Integer] the comment controversiality
+      property :controversiality
+
+      # @!attribute [r] depth
+      #   @return [Integer] the comment depth
+      property :depth
+
+      # @!attribute [r] mod_reports
+      #   @return [Array<String>] the moderator reports
+      property :mod_reports
+
+      # @!attribute [r] report_count
+      #   @return [Integer] the report count
+      property :report_count, from: :num_reports
+
+      # @!attribute [r] distinguished?
+      #   @return [Boolean] whether the comment is distinguished
+      property :distinguished?, from: :distinguished
+
+      private
 
-      def default_loader
-        @attributes.key?(:link_id) ? load_with_comments : load_without_comments
+      def lazer_reload
+        self[:link] ? load_with_comments : load_without_comments
       end
 
       def load_with_comments
-        id = @attributes.fetch(:id) { @attributes.fetch(:name).sub('t1_', '') }
-        link_id = @attributes[:link_id].sub('t3_', '')
-        @client.get("/comments/#{link_id}/_/#{id}").body[1][:data][:children][0][:data]
+        fully_loaded!
+        id = self[:id] || read_attribute(:name).sub('t1_', '')
+        link_id = read_attribute(:link).name.sub('t3_', '')
+        client.get("/comments/#{link_id}/_/#{id}").body[1][:data][:children][0][:data]
       end
 
       def load_without_comments
-        id = @attributes.fetch(:id) { @attributes.fetch(:name).sub('t1_', '') }
-        @client.get('/api/info', id: "t1_#{id}").body[:data][:children][0][:data]
+        id = self[:id] || read_attribute(:name).sub('t1_', '')
+        response = client.get('/api/info', id: "t1_#{id}").body[:data][:children][0][:data]
+        response.delete(:replies) # Make sure replies are lazy-loaded later.
+        response
       end
     end
   end

data/lib/redd/models/front_page.rb

@@ -1,41 +1,41 @@
 # frozen_string_literal: true
 
-require_relative 'basic_model'
-require_relative '../utilities/stream'
+require_relative 'model'
 
 module Redd
   module Models
     # The front page.
     # FIXME: deal with serious code duplication from Subreddit
-    class FrontPage < BasicModel
+    class FrontPage < Model
       # @return [Array<String>] reddit's base wiki pages
       def wiki_pages
-        @client.get('/wiki/pages').body[:data]
+        client.get('/wiki/pages').body[:data]
       end
 
       # Get a wiki page by its title.
       # @param title [String] the page's title
       # @return [WikiPage]
       def wiki_page(title)
-        WikiPage.new(@client, title: title)
+        WikiPage.new(client, title: title)
       end
 
       # Get the appropriate listing.
       # @param sort [:hot, :new, :top, :controversial, :comments, :rising, :gilded] the type of
       #   listing
-      # @param params [Hash] a list of params to send with the request
-      # @option params [String] :after return results after the given fullname
-      # @option params [String] :before return results before the given fullname
-      # @option params [Integer] :count the number of items already seen in the listing
-      # @option params [1..100] :limit the maximum number of things to return
-      # @option params [:hour, :day, :week, :month, :year, :all] :time the time period to consider
+      # @param options [Hash] a list of options to send with the request
+      # @option options [String] :after return results after the given fullname
+      # @option options [String] :before return results before the given fullname
+      # @option options [Integer, nil] :limit maximum number of items to return (nil for no limit)
+      # @option options [:hour, :day, :week, :month, :year, :all] :time the time period to consider
       #   when sorting.
       #
       # @note The option :time only applies to the top and controversial sorts.
-      # @return [Listing<Submission>]
-      def listing(sort, **params)
-        params[:t] = params.delete(:time) if params.key?(:time)
-        @client.model(:get, "/#{sort}", params)
+      # @return [PaginatedListing<Submission>]
+      def listing(sort, **options)
+        options[:t] = options.delete(:time) if options.key?(:time)
+        PaginatedListing.new(client, options) do |**req_options|
+          client.model(:get, "/#{sort}", options.merge(req_options))
+        end
       end
 
       # @!method hot(**params)
@@ -47,29 +47,9 @@ module Redd
       # @!method gilded(**params)
       #
       # @see #listing
-      %i(hot new top controversial comments rising gilded).each do |sort|
+      %i[hot new top controversial comments rising gilded].each do |sort|
         define_method(sort) { |**params| listing(sort, **params) }
       end
-
-      # Stream newly submitted posts.
-      def post_stream(**params, &block)
-        params[:limit] ||= 100
-        stream = Utilities::Stream.new do |previous|
-          before = previous ? previous.first.name : nil
-          listing(:new, params.merge(before: before))
-        end
-        block_given? ? stream.stream(&block) : stream.enum_for(:stream)
-      end
-
-      # Stream newly submitted comments.
-      def comment_stream(**params, &block)
-        params[:limit] ||= 100
-        stream = Utilities::Stream.new do |previous|
-          before = previous ? previous.first.name : nil
-          listing(:comments, params.merge(before: before))
-        end
-        block_given? ? stream.stream(&block) : stream.enum_for(:stream)
-      end
     end
   end
 end

data/lib/redd/models/gildable.rb

@@ -6,7 +6,7 @@ module Redd
     module Gildable
       # Gift a user one month of reddit gold for their link or comment.
       def gild
-        @client.post("/api/v1/gold/gild/#{get_attribute(:name)}")
+        client.post("/api/v1/gold/gild/#{read_attribute(:name)}")
       end
     end
   end

data/lib/redd/models/inboxable.rb

@@ -6,17 +6,27 @@ module Redd
     module Inboxable
       # Block the user that sent this item.
       def block
-        @client.post('/api/block', id: get_attribute(:name))
+        client.post('/api/block', id: read_attribute(:name))
+      end
+
+      # Collapse the item.
+      def collapse
+        client.post('/api/collapse_message', id: read_attribute(:name))
+      end
+
+      # Uncollapse the item.
+      def uncollapse
+        client.post('/api/uncollapse_message', id: read_attribute(:name))
       end
 
       # Mark this thing as read.
       def mark_as_read
-        @client.post('/api/read_message', id: get_attribute(:name))
+        client.post('/api/read_message', id: read_attribute(:name))
       end
 
       # Mark one or more messages as unread.
       def mark_as_unread
-        @client.post('/api/unread_message', id: get_attribute(:name))
+        client.post('/api/unread_message', id: read_attribute(:name))
       end
     end
   end

data/lib/redd/models/listing.rb

@@ -1,24 +1,45 @@
 # frozen_string_literal: true
 
-require_relative 'basic_model'
+require_relative 'model'
 
 module Redd
   module Models
     # A backward-expading listing of items.
     # @see Stream
-    class Listing < BasicModel
+    class Listing < Model
       include Enumerable
 
+      # Create a fully initialized listing.
+      # @param client [APIClient] the api client
+      # @param attributes [Hash] the attribute hash
+      def initialize(client, attributes = {})
+        super
+        fully_loaded!
+      end
+
       # @return [Array<Comment, Submission, PrivateMessage>] an array representation of self
-      def to_ary
-        get_attribute(:children)
+      def to_a
+        read_attribute(:children)
       end
+      alias to_ary to_a
 
-      %i([] each empty? first last).each do |method_name|
+      %i[[] each empty? first last].each do |method_name|
         define_method(method_name) do |*args, &block|
-          get_attribute(:children).public_send(method_name, *args, &block)
+          read_attribute(:children).public_send(method_name, *args, &block)
         end
       end
+
+      # @!attribute [r] before
+      #   @return [String] the fullname of the item before this listing
+      property :before, :nil
+
+      # @!attribute [r] after
+      #   @return [String] the fullname of the item that the next listing will start from
+      property :after, :nil
+
+      # @!attribute [r] children
+      #   @return [Array<Model>] the listing's children
+      property :children, :required, with: ->(a) { a.map { |m| client.unmarshal(m) } }
     end
   end
 end