redd 0.8.8 → 0.9.0.pre.1

data/lib/redd/models/modmail_message.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'time'
+require_relative 'model'
+
+module Redd
+  module Models
+    # Represents a message in the new modmail.
+    class ModmailMessage < Model
+      # @!attribute [r] id
+      #   @return [String] the message id
+      property :id
+
+      # @!attribute [r] body
+      #   @return [String] the html conversation body
+      property :body
+
+      # @!attribute [r] markdown_body
+      #   @return [String] the body in markdown form
+      property :markdown_body, from: :bodyMarkdown
+
+      # @!attribute [r] author
+      #   @return [Object] FIXME: do shit
+      property :author
+
+      # @!attribute [r] internal?
+      #   @return [Boolean] whether the message is internal
+      property :internal?, from: :isInternal
+
+      # @!attribute [r] date
+      #   @return [Time] the message date
+      property :date, with: ->(t) { Time.parse(t) }
+    end
+  end
+end

data/lib/redd/models/more_comments.rb

@@ -1,20 +1,20 @@
 # frozen_string_literal: true
 
-require_relative 'basic_model'
+require_relative 'model'
 
 module Redd
   module Models
     # An object that represents a bunch of comments that need to be expanded.
-    class MoreComments < BasicModel
+    class MoreComments < Model
       # Expand the object's children into a listing of Comments and MoreComments.
       # @param link [Submission] the submission the object belongs to
       # @param sort [String] the sort order of the submission
       # @return [Listing<Comment, MoreComments>] the expanded children
       def expand(link:, sort: nil)
-        params = { link_id: link.name, children: get_attribute(:children).join(',') }
+        params = { link_id: link.name, children: read_attribute(:children).join(',') }
         params[:sort] = sort if sort
         params[:sort] = link.sort_order if link.sort_order
-        @client.model(:get, '/api/morechildren', params)
+        client.model(:get, '/api/morechildren', params)
       end
 
       # Keep expanding until all top-level MoreComments are converted to comments.
@@ -44,8 +44,32 @@ module Redd
 
       # @return [Array<String>] an array representation of self
       def to_ary
-        get_attribute(:children)
+        read_attribute(:children)
       end
+
+      # @!attribute [r] count
+      #   @return [Integer] the comments under this object
+      property :count
+
+      # @!attribute [r] name
+      #   @return [String] the object fullname
+      property :name
+
+      # @!attribute [r] id
+      #   @return [String] the object id
+      property :id
+
+      # @!attribute [r] parent_id
+      #   @return [String] the parent fullname
+      property :parent_id
+
+      # @!attribute [r] depth
+      #   @return [Integer] the depth
+      property :depth
+
+      # @!attribute [r] children
+      #   @return [Array<String>] the unexpanded comments
+      property :children
     end
   end
 end

data/lib/redd/models/multireddit.rb

@@ -1,19 +1,11 @@
 # frozen_string_literal: true
 
-require_relative 'lazy_model'
+require_relative 'model'
 
 module Redd
   module Models
     # A multi.
-    class Multireddit < LazyModel
-      # Create a Multireddit from its path.
-      # @param client [APIClient] the api client to initialize the object with
-      # @param id [String] the multi's path (with a leading and trailing slash)
-      # @return [Multireddit]
-      def self.from_id(client, id)
-        new(client, path: id)
-      end
-
+    class Multireddit < Model
       # Get the appropriate listing.
       # @param sort [:hot, :new, :top, :controversial, :comments, :rising, :gilded] the type of
       #   listing
@@ -29,7 +21,7 @@ module Redd
       # @return [Listing<Submission>]
       def listing(sort, **params)
         params[:t] = params.delete(:time) if params.key?(:time)
-        @client.model(:get, "#{get_attribute(:path)}#{sort}", params)
+        client.model(:get, "#{read_attribute(:path)}#{sort}", params)
       end
 
       # @!method hot(**params)
@@ -41,20 +33,71 @@ 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
 
-      private
+      # @!attribute [r] can_edit?
+      #   @return [Boolean] whether the user can edit the multireddit
+      property :can_edit?, from: :can_edit
 
-      def after_initialize
-        @attributes[:subreddits].map! do |subreddit|
-          Subreddit.new(client, display_name: subreddit[:name])
-        end
-      end
+      # @!attribute [r] display_name
+      #   @return [String] the multi's display name
+      property :display_name
+
+      # @!attribute [r] name
+      #   @return [String] the multireddit name
+      property :name
+
+      # @!attribute [r] description_md
+      #   @return [String] the markdown verion of the description
+      property :description_md
+
+      # @!attribute [r] description_html
+      #   @return [String] the html-rendered description
+      property :description_html
+
+      # @!attribute [r] copied_from
+      #   @return [Multireddit, nil] the multi this one was copied from
+      property :copied_from, with: ->(n) { Multireddit.new(client, path: n) if n }
+
+      # @!attribute [r] icon_url
+      #   @return [String, nil] the icon url
+      property :icon_url
+
+      # @!attribute [r] subreddits
+      #   @return [Array<Subreddit>] the subreddits in this multi
+      property :subreddits,
+               with: ->(a) { a.map { |n| Subreddit.new(client, display_name: n.fetch(:name)) } }
+
+      # @!attribute [r] created_at
+      #   @return [Time] the creation time
+      property :created_at, from: :created_utc, with: ->(t) { Time.at(t) }
+
+      # @!attribute [r] key_color
+      #   @return [String] a hex color
+      property :key_color
+
+      # @!attribute [r] visibility
+      #   @return [String] the multi visibility, either "public" or "private"
+      property :visibility
+
+      # @!attribute [r] icon_name
+      #   @return [String] the icon name
+      property :icon_name
+
+      # @!attribute [r] weighting_scheme
+      #   @return [String]
+      property :weighting_scheme
+
+      # @!attribute [r] path
+      #   @return [String] the multi path
+      property :path, :required
+
+      private
 
-      def default_loader
-        @client.get("/api/multi#{@attributes.fetch(:path)}").body[:data]
+      def lazer_reload
+        client.get("/api/multi#{read_attribute(:path)}").body[:data]
       end
     end
   end

data/lib/redd/models/paginated_listing.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require_relative 'model'
+
+module Redd
+  module Models
+    # An enumerable type that covers listings and expands forwards.
+    class PaginatedListing
+      include Enumerable
+
+      # A simple fixed-size ring buffer.
+      # @api private
+      class RingBuffer
+        def initialize(size)
+          @size = size
+          @backing_array = Array.new(size)
+          @pointer = 0
+        end
+
+        def include?(el)
+          @backing_array.include?(el)
+        end
+
+        def add(el)
+          @backing_array[@pointer] = el
+          @pointer = (@pointer + 1) % @size
+        end
+      end
+
+      # Create an expandable listing.
+      # @param client [APIClient] the caller to use for streams
+      # @param options [Hash]
+      # @option options [String] :before the listing's before parameter
+      # @option options [String] :after the listing's after parameter
+      # @option options [Integer] :limit the maximum number of items to fetch
+      # @yieldparam after [String] the fullname of the item to fetch after
+      # @yieldparam limit [Integer] the number of items to fetch (max 100)
+      # @yieldreturn [Listing] the listing to return
+      def initialize(client, **options, &block)
+        raise ArgumentError, 'block must be provided' unless block_given?
+
+        @client = client
+        @caller = block
+        @before = options[:before]
+        @after = options[:after]
+        @limit = options[:limit] || 1000
+      end
+
+      # Go forward through the listing.
+      # @yield [Model] the object returned in the listings
+      # @return [Enumerator] if a block wasn't provided
+      def each(&block)
+        return _each(&block) if block_given?
+        enum_for(:_each)
+      end
+
+      # Stream through the listing.
+      # @note If you iterate through the stream, you'll loop forever.
+      #   This may or may not be desirable.
+      # @yield [Model] the object returned in the listings
+      # @return [Enumerator] if a block wasn't provided
+      def stream(&block)
+        return _stream(&block) if block_given?
+        enum_for(:_stream)
+      end
+
+      private
+
+      # Go backward through the listing.
+      # @yield [Object] the object returned in the listings
+      def _stream(&block)
+        reverse_each(&block) if @limit > 0
+        buffer = RingBuffer.new(100)
+        loop do
+          remaining = fetch_prev_listing
+          remaining.reverse_each do |o|
+            next if buffer.include?(o)
+            yield o
+            buffer.add(o)
+          end
+        end
+      end
+
+      # Go forward through the listing.
+      # @yield [Object] the object returned in the listings
+      def _each(&block)
+        loop do
+          return if @limit == 0
+          remaining = fetch_next_listing
+          return if remaining.children.empty? # if the fetched listing is empty
+          remaining.each(&block)
+          return if remaining.after.nil? # if there's no link to the next item
+        end
+      end
+
+      # Fetch the next listing with @caller and update @after and @limit.
+      def fetch_next_listing
+        caller_limit = [@limit, 100].min
+        listing = @caller.call(before: nil, after: @after, limit: caller_limit)
+        @after = listing.after
+        @limit -= caller_limit
+        listing
+      end
+
+      # Fetch the previous listing with @caller and update @before.
+      def fetch_prev_listing
+        listing = @caller.call(before: @before, after: nil, limit: 100)
+        @before = listing.first.name unless listing.empty?
+        listing
+      end
+    end
+  end
+end

data/lib/redd/models/postable.rb

@@ -8,37 +8,36 @@ module Redd
       # @param text [String] The new text.
       # @return [self] the edited thing
       def edit(text)
-        @client.post('/api/editusertext', thing_id: get_attribute(:name), text: text)
-        @attributes[is_a?(Submission) ? :selftext : :body] = text
+        client.post('/api/editusertext', thing_id: read_attribute(:name), text: text)
         self
       end
 
       # Delete the thing.
       def delete
-        @client.post('/api/del', id: get_attribute(:name))
+        client.post('/api/del', id: read_attribute(:name))
       end
 
       # Save a link or comment to the user's account.
       # @param category [String] a category to save to
       def save(category = nil)
-        params = { id: get_attribute(:name) }
+        params = { id: read_attribute(:name) }
         params[:category] = category if category
-        @client.post('/api/save', params)
+        client.post('/api/save', params)
       end
 
       # Remove the link or comment from the user's saved links.
       def unsave
-        @client.post('/api/unsave', id: get_attribute(:name))
+        client.post('/api/unsave', id: read_attribute(:name))
       end
 
       # Hide a link from the user.
       def hide
-        @client.post('/api/hide', id: get_attribute(:name))
+        client.post('/api/hide', id: read_attribute(:name))
       end
 
       # Unhide a previously hidden link.
       def unhide
-        @client.post('/api/unhide', id: get_attribute(:name))
+        client.post('/api/unhide', id: read_attribute(:name))
       end
 
       # Upvote the model.
@@ -58,12 +57,12 @@ module Redd
 
       # Send replies to this thing to the user's inbox.
       def enable_inbox_replies
-        @client.post('/api/sendreplies', id: get_attribute(:name), state: true)
+        client.post('/api/sendreplies', id: read_attribute(:name), state: true)
       end
 
       # Stop sending replies to this thing to the user's inbox.
       def disable_inbox_replies
-        @client.post('/api/sendreplies', id: get_attribute(:name), state: false)
+        client.post('/api/sendreplies', id: read_attribute(:name), state: false)
       end
 
       private
@@ -71,9 +70,8 @@ module Redd
       # Send a vote.
       # @param direction [-1, 0, 1] the direction to vote in
       def vote(direction)
-        fullname = get_attribute(:name)
-        @client.post('/api/vote', id: fullname, dir: direction)
-        @attributes[:ups] += direction
+        fullname = read_attribute(:name)
+        client.post('/api/vote', id: fullname, dir: direction)
       end
     end
   end

data/lib/redd/models/private_message.rb

@@ -1,38 +1,105 @@
 # frozen_string_literal: true
 
-require_relative 'lazy_model'
+require_relative 'model'
 require_relative 'inboxable'
 require_relative 'replyable'
+require_relative 'reportable'
 
 module Redd
   module Models
     # A private message
-    class PrivateMessage < LazyModel
+    class PrivateMessage < Model
       include Inboxable
       include Replyable
+      include Reportable
 
       # Delete the message from the user's inbox.
       def delete
-        @client.post('/api/del_msg', id: get_attribute(:name))
+        client.post('/api/del_msg', id: read_attribute(:name))
       end
 
       # Mute the author of the message.
       def mute_author
-        @client.post('/api/mute_message_author', id: get_attribute(:name))
+        client.post('/api/mute_message_author', id: read_attribute(:name))
       end
 
       # Unmute the author of the message.
       def unmute_author
-        @client.post('/api/unmute_message_author', id: get_attribute(:name))
+        client.post('/api/unmute_message_author', id: read_attribute(:name))
       end
 
-      private
+      # @!attribute [r] first_message
+      #   @return [Integer] not sure what this does
+      property :first_message
 
-      def default_loader
-        # FIXME: This returns the entire conversation, not the specific message. Possible to search,
-        #   because depth of replies is just one.
-        {}
-      end
+      # @!attribute [r] first_message_name
+      #   @return [String] the fullname of the first message
+      property :first_message_name
+
+      # @!attribute [r] subreddit
+      #   @return [Subreddit, nil] the subreddit that sent the message
+      property :subreddit, with: ->(s) { Subreddit.new(client, display_name: s) if s }
+
+      # @!attribute [r] replies
+      #   @return [Listing<PrivateMessage>]
+      property :replies, with: ->(l) { Listing.new(client, l[:data]) if l.is_a?(Hash) }
+
+      # @!attribute [r] id
+      #   @return [String] the message id
+      property :id
+
+      # @!attribute [r] subject
+      #   @return [String] the message subject
+      property :subject
+
+      # @!attribute [r] was_comment?
+      #   @return [Boolean]
+      property :was_comment?, from: :was_comment
+
+      # @!attribute [r] author
+      #   @return [User] the message author
+      property :author, with: ->(n) { User.new(client, name: n) if n }
+
+      # @!attribute [r] num_comments
+      #   @return [Integer] huh?
+      property :num_comments
+
+      # @!attribute [r] parent_id
+      #   @return [String, nil] the parent id
+      property :parent_id
+
+      # @!attribute [r] subreddit_name_prefixed
+      #   @return [String] the subreddit name, prefixed with "r/"
+      property :subreddit_name_prefixed
+
+      # @!attribute [r] new?
+      #   @return [Boolean] whether the message is new
+      property :new?, from: :new
+
+      # @!attribute [r] body
+      #   @return [String] the message body
+      property :body
+
+      # @!attribute [r] body_html
+      #   @return [String] the html-rendered version of the body
+      property :body_html
+
+      # @!attribute [r] dest
+      #   @return [String] the recipient of the message
+      #   @todo maybe convert the object to Subreddit/User?
+      property :dest
+
+      # @!attribute [r] name
+      #   @return [String] the message fullname
+      property :name
+
+      # @!attribute [r] created
+      #   @return [Time] the time the message was created
+      property :created_utc, with: ->(t) { Time.at(t) }
+
+      # @!attribute [r] distinguished
+      #   @return [String] the level the message is distinguished
+      property :distinguished
     end
   end
 end