spinels-redd 0.9.0

data/lib/redd/models/more_comments.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require_relative 'model'
+
+module Redd
+  module Models
+    # An object that represents a bunch of comments that need to be expanded.
+    class MoreComments < Model
+      # Expand the object's children into a listing of Comments and MoreComments.
+      # @param link [Submission] the submission the object belongs to
+      # @return [Listing<Comment, MoreComments>] the expanded children
+      def expand(link:)
+        expand_recursive(link: link, lookup: {})
+      end
+
+      # @return [Array<String>] an array representation of self
+      def to_a
+        read_attribute(:children)
+      end
+      alias to_ary to_a
+
+      # @!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
+
+      protected
+
+      # Keep expanding until all top-level MoreComments are converted to comments.
+      # @param link [Submission] the object's submission
+      # @param lookup [Hash] a hash of comments to add future replies to
+      # @return [Array<Comment, MoreComments>] the expanded comments or self if past depth
+      def expand_recursive(link:, lookup:) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+        return [self] if depth == 0
+
+        expand_one(link: link).each_with_object([]) do |thing, coll|
+          target =
+            if thing.parent_id == read_attribute(:parent_id)
+              coll
+            elsif lookup.key?(thing.parent_id)
+              lookup[thing.parent_id].replies.children
+            end
+
+          if target.nil?
+            warn "expanding error: orphaned comment #{thing.name}"
+            next
+          end
+
+          if thing.is_a?(Comment)
+            # Add the comment to a lookup hash.
+            lookup[thing.name] = thing
+            # If the parent is not in the lookup hash, add it to the root listing.
+            target.push(thing)
+          elsif thing.is_a?(MoreComments) && thing.count > 0
+            if thing.parent_id == read_attribute(:parent_id)
+              ary = thing.expand_recursive(link: link, lookup: lookup, depth: depth - 1)
+              target.concat(ary)
+            else
+              target.push(thing)
+            end
+          end
+        end
+      end
+
+      private
+
+      # Expand the object's children into a listing of Comments and MoreComments.
+      # @param link [Submission] the submission the object belongs to
+      # @return [Listing<Comment, MoreComments>] the expanded children
+      def expand_one(link:)
+        params = { link_id: link.name, children: read_attribute(:children).join(',') }
+        params[:sort] = link.sort_order if link.sort_order
+        client.model(:post, '/api/morechildren', params)
+      end
+    end
+  end
+end

data/lib/redd/models/multireddit.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require_relative 'model'
+
+module Redd
+  module Models
+    # A multi.
+    class Multireddit < Model
+      # 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
+      #   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, "#{read_attribute(:path)}#{sort}", params)
+      end
+
+      # @!method hot(**params)
+      # @!method new(**params)
+      # @!method top(**params)
+      # @!method controversial(**params)
+      # @!method comments(**params)
+      # @!method rising(**params)
+      # @!method gilded(**params)
+      #
+      # @see #listing
+      %i[hot new top controversial comments rising gilded].each do |sort|
+        define_method(sort) { |**params| listing(sort, **params) }
+      end
+
+      # @!attribute [r] can_edit?
+      #   @return [Boolean] whether the user can edit the multireddit
+      property :can_edit?, from: :can_edit
+
+      # @!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 lazer_reload
+        client.get("/api/multi#{read_attribute(:path)}").body[:data]
+      end
+    end
+  end
+end

data/lib/redd/models/paginated_listing.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require_relative 'model'
+
+module Redd
+  module Models
+    # An enumerable type that covers listings and expands forwards.
+    #
+    # If you want to use the #[] operator, you'll need to convert the object to an Array. This can
+    # be done with either {Enumerable#first} or {Enumerable#to_a}.
+    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?(element)
+          @backing_array.include?(element)
+        end
+
+        def add(element)
+          @backing_array[@pointer] = element
+          @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 # rubocop:disable Metrics/MethodLength
+        buffer = RingBuffer.new(100)
+        remaining = @limit > 0 ? reverse_each.to_a : []
+
+        loop do
+          remaining.push(*fetch_prev_listing)
+          remaining.reverse_each do |o|
+            next if buffer.include?(o.id)
+
+            buffer.add(o.id)
+            yield o
+          end
+          remaining.clear
+        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(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
+        # we're not using the user-provided because a stream isn't supposed to die
+        listing = @caller.call(before: @before, after: nil, limit: 100)
+        @before = listing.empty? ? nil : listing.first.name
+        listing
+      end
+    end
+  end
+end

data/lib/redd/models/postable.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Redd
+  module Models
+    # Methods for user-submitted content, i.e. Submissions and Comments.
+    module Postable
+      # Edit a thing.
+      # @param text [String] The new text.
+      # @return [self] the edited thing
+      def edit(text)
+        client.post('/api/editusertext', thing_id: read_attribute(:name), text: text)
+        self
+      end
+
+      # Delete the thing.
+      def delete
+        client.post('/api/del', id: read_attribute(:name))
+      end
+
+      # @return [Boolean] whether the item is probably deleted
+      def deleted?
+        read_attribute(:author).name == '[deleted]'
+      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: read_attribute(:name) }
+        params[:category] = category if category
+        client.post('/api/save', params)
+      end
+
+      # Remove the link or comment from the user's saved links.
+      def unsave
+        client.post('/api/unsave', id: read_attribute(:name))
+      end
+
+      # Hide a link from the user.
+      def hide
+        client.post('/api/hide', id: read_attribute(:name))
+      end
+
+      # Unhide a previously hidden link.
+      def unhide
+        client.post('/api/unhide', id: read_attribute(:name))
+      end
+
+      # Upvote the model.
+      def upvote
+        vote(1)
+      end
+
+      # Downvote the model.
+      def downvote
+        vote(-1)
+      end
+
+      # Clear any upvotes or downvotes on the model.
+      def undo_vote
+        vote(0)
+      end
+
+      # Send replies to this thing to the user's inbox.
+      def enable_inbox_replies
+        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: read_attribute(:name), state: false)
+      end
+
+      private
+
+      # Send a vote.
+      # @param direction [-1, 0, 1] the direction to vote in
+      def vote(direction)
+        fullname = read_attribute(:name)
+        client.post('/api/vote', id: fullname, dir: direction)
+      end
+    end
+  end
+end

data/lib/redd/models/private_message.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require_relative 'model'
+require_relative 'inboxable'
+require_relative 'replyable'
+require_relative 'reportable'
+
+module Redd
+  module Models
+    # A private message
+    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: read_attribute(:name))
+      end
+
+      # Mute the author of the message.
+      def mute_author
+        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: read_attribute(:name))
+      end
+
+      # @!attribute [r] first_message
+      #   @return [Integer] not sure what this does
+      property :first_message
+
+      # @!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

data/lib/redd/models/replyable.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Redd
+  module Models
+    # A model that can be commented on or replied to.
+    module Replyable
+      # Add a comment to a link, reply to a comment or reply to a message.
+      # @param text [String] the text to comment
+      # @return [Comment, PrivateMessage] The created reply.
+      def reply(text)
+        fullname = read_attribute(:name)
+        client.model(:post, '/api/comment', text: text, thing_id: fullname).first
+      end
+    end
+  end
+end

data/lib/redd/models/reportable.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Redd
+  module Models
+    # Things that can be reported (except users).
+    module Reportable
+      # Report the object.
+      # @param reason [String] the report reason
+      def report(reason)
+        client.post('/api/report', thing_id: read_attribute(:name), reason: reason)
+      end
+    end
+  end
+end

data/lib/redd/models/searchable.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Redd
+  module Models
+    # Applied to {Session} for site-wide and {Subreddit} for subreddit-specific search.
+    module Searchable
+      # Search reddit.
+      # @see https://www.reddit.com/wiki/search
+      #
+      # @param query [String] the search query
+      # @param params [Hash] the search params
+      # @option params [:cloudsearch, :lucene, :plain] :syntax the query's syntax
+      # @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 restrict
+      #   search results by
+      # @option params [:relevance, :hot, :top, :new, :comments] :sort the sort order of results
+      # @option params [String] :restrict_to restrict by subreddit (prefer {Subreddit#search})
+      # @return [Listing<Comment, Submission>] the search results
+      def search(query, **params)
+        params[:q] = query
+        params[:t] = params.delete(:time) if params.key?(:time)
+        if params[:restrict_to]
+          subreddit = params.delete(:restrict_to)
+          params[:restrict_sr] = true
+          client.model(:get, "/r/#{subreddit}/search", params)
+        else
+          client.model(:get, '/search', params)
+        end
+      end
+    end
+  end
+end

data/lib/redd/models/self.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'user'
+
+module Redd
+  module Models
+    # The user that the bot is running under.
+    class Self < User
+      private
+
+      def lazer_reload
+        fully_loaded!
+        client.get('/api/v1/me').body
+      end
+    end
+  end
+end