spinels-redd 0.9.0

data/lib/redd/models/listing.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative 'model'
+
+module Redd
+  module Models
+    # A backward-expading listing of items.
+    # @see Stream
+    class Listing < Model
+      include Enumerable
+
+      # Create an empty listing with a client.
+      # @param client [APIClient] the client to create the listing with
+      # @return [Listing] the empty listing
+      def self.empty(client)
+        Listing.new(client, children: [])
+      end
+
+      # 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_a
+        read_attribute(:children)
+      end
+      alias to_ary to_a
+
+      %i[[] each empty? first last].each do |method_name|
+        define_method(method_name) do |*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

data/lib/redd/models/live_thread.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require_relative 'model'
+
+module Redd
+  module Models
+    # Represents a live thread.
+    class LiveThread < Model
+      # Get the updates from the thread.
+      # @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
+      # @return [Listing]
+      def updates(**params)
+        client.model(:get, "/live/#{read_attribute(:id)}", params)
+      end
+
+      # Configure the settings of this live thread
+      # @param params [Hash] a list of params to send with the request
+      # @option params [String] :description the new description
+      # @option params [Boolean] :nsfw whether the thread is for users 18 and above
+      # @option params [String] :resources the new resources
+      # @option params [String] :title the thread title
+      def configure(**params)
+        client.post("/api/live/#{read_attribute(:id)}/edit", params)
+      end
+
+      # Add an update to this live event.
+      # @param body [String] the update text
+      def update(body)
+        client.post("/api/live/#{read_attribute(:id)}/update", body: body)
+      end
+
+      # Strike out a live thread update.
+      # @param live_update [LiveUpdate] the update to strike out
+      def strike_update(live_update)
+        client.post("/api/live/#{read_attribute(:id)}/strike_update", id: live_update.name)
+      end
+
+      # Delete a live thread update.
+      # @param live_update [LiveUpdate] the update to strike out
+      def delete_update(live_update)
+        client.post("/api/live/#{read_attribute(:id)}/delete_update", id: live_update.name)
+      end
+
+      # @return [Array<User>] the contributors to this thread
+      def contributors
+        client.get("/live/#{read_attribute(:id)}/contributors").body[0][:data].map do |user|
+          User.new(client, user)
+        end
+      end
+
+      # @return [Array<User>] users invited to contribute to this thread
+      def invited_contributors
+        client.get("/live/#{read_attribute(:id)}/contributors").body[1][:data].map do |user|
+          User.new(client, user)
+        end
+      end
+
+      # Returns all discussions that link to this live thread.
+      # @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
+      #
+      # @return [Listing<Submission>]
+      def discussions(**params)
+        client.model(:get, "/live/#{read_attribute(:id)}/discussions", params)
+      end
+
+      # @!attribute [r] id
+      #   @return [String] the thread id
+      property :id, :required
+
+      # @!attribute [r] name
+      #   @return [String] the thread fullname
+      property :name, default: -> { "LiveUpdateEvent_#{read_attribute(:id)}" }
+
+      # @!attribute [r] description
+      #   @return [String] the live thread description
+      property :description
+
+      # @!attribute [r] description_html
+      #   @return [String] the html-rendered thread description
+      property :description_html
+
+      # @!attribute [r] title
+      #   @return [String] the live thread title
+      property :title
+
+      # @!attribute [r] created_at
+      #   @return [String] the live thread creation time
+      property :created_at, from: :created_utc, with: ->(t) { Time.at(t) }
+
+      # @!attribute [r] websocket_url
+      #   @return [String] the websocket url for listening to updates
+      property :websocket_url
+
+      # @!attribute [r] state
+      #   @return [String] the thread state (e.g. "live")
+      property :state
+
+      # @!attribute [r] nsfw?
+      #   @return [Boolean] whether the thread is nsfw
+      property :nsfw?, from: :nsfw
+
+      # @!attribute [r] viewer_count
+      #   @return [Integer] the thread viewer count
+      property :viewer_count
+
+      # @!attribute [r] viewer_count_fuzzed?
+      #   @return [Boolean] whether the viewer count is fuzzed
+      property :viewer_count_fuzzed?, from: :viewer_count_fuzzed
+
+      # @!attribute [r] resources
+      #   @return [String] the thread's resources section
+      property :resources
+
+      # @!attribute [r] resources_html
+      #   @return [String] the html-rendered thread resources
+      property :resources_html
+
+      private
+
+      def lazer_reload
+        client.get("/live/#{read_attribute(:id)}/about").body[:data]
+      end
+    end
+  end
+end

data/lib/redd/models/live_update.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative 'model'
+
+module Redd
+  module Models
+    # A live thread update.
+    class LiveUpdate < Model
+      # @!attribute [r] id
+      #   @return [String] the update id
+      property :id, :required
+
+      # @!attribute [r] name
+      #   @return [String] the update fullname
+      property :name, default: -> { "LiveUpdate_#{read_attribute(:id)}" }
+
+      # @!attribute [r] body
+      #   @return [String] the update body
+      property :body
+
+      # @!attribute [r] body_html
+      #   @return [String] the html-rendered update body
+      property :body_html
+
+      # @!attribute [r] embeds
+      #   @return [Array]
+      property :embeds
+
+      # @!attribute [r] mobile_embeds
+      #   @return [Array]
+      property :mobile_embeds
+
+      # @!attribute [r] author
+      #   @return [User] the poster of the update
+      property :author, with: ->(n) { User.new(client, name: n) }
+
+      # @!attribute [r] created_at
+      #   @return [Time] the post time
+      property :created_at, from: :created_utc, with: ->(t) { Time.at(t) }
+
+      # @!attribute [r] stricken?
+      #   @return [Boolean] whether the update is stricken
+      property :stricken?, from: :stricken
+    end
+  end
+end

data/lib/redd/models/messageable.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Redd
+  module Models
+    # A model that can be messaged (i.e. Users and Subreddits).
+    module Messageable
+      # Compose a message to a person or the moderators of a subreddit.
+      #
+      # @param to [String] the thing to send the message to (overriden by User and Subreddit)
+      # @param subject [String] the subject of the message
+      # @param text [String] the message text
+      # @param from [Subreddit, nil] the subreddit to send the message on behalf of
+      def send_message(to:, subject:, text:, from: nil)
+        params = { to: to, subject: subject, text: text }
+        params[:from_sr] = from.display_name if from
+        client.post('/api/compose', params)
+      end
+    end
+  end
+end

data/lib/redd/models/mod_action.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative 'model'
+
+module Redd
+  module Models
+    # Represents a moderator action, part of a moderation log.
+    # @see Subreddit#mod_log
+    class ModAction < Model
+      # @!attribute [r] description
+      #   @return [String] the action description
+      property :description
+
+      # @!attribute [r] target_title
+      #   @return [String] the title of the item that was targeted
+      property :target_title
+
+      # @!attribute [r] target_body
+      #   @return [String] the body of the item that was targeted
+      property :target_body
+
+      # @!attribute [r] target_permalink
+      #   @return [String] the **relative** permalink to the item
+      property :target_permalink
+
+      # @!attribute [r] target_author
+      #   @return [User] the target user
+      property :target_author, with: ->(n) { User.new(client, name: n) }
+
+      # @!attribute [r] mod_id36
+      #   @return [String] the id of the moderator that performed this action
+      property :mod_id36
+
+      # @!attribute [r] created_at
+      #   @return [Time] the time when the action was done
+      property :created_at, from: :created_utc, with: ->(t) { Time.at(t) }
+
+      # @!attribute [r] subreddit
+      #   @return [Subreddit] the subreddit the action was performed on
+      property :subreddit, with: ->(n) { Subreddit.new(client, display_name: n) }
+
+      # @!attribute [r] subreddit_name_prefixed
+      #   @return [String] the subreddit name, prefixed with a "r/"
+      property :subreddit_name_prefixed
+
+      # @!attribute [r] subreddit_id36
+      #   @return [String] the subreddit's id
+      property :subreddit_id36, from: :sr_id36
+
+      # @!attribute [r] details
+      #   @return [String] the action details
+      property :details
+
+      # @!attribute [r] action
+      #   @return [String] the action type
+      property :action
+    end
+  end
+end

data/lib/redd/models/model.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'lazy_lazer'
+
+module Redd
+  module Models
+    # A base model class.
+    class Model
+      include LazyLazer
+
+      # @return [Client] the model's client
+      attr_reader :client
+
+      # Create a new Model.
+      # @param client [Client] the model's client
+      # @param attributes [Hash] the model's attributes
+      def initialize(client, attributes = {})
+        super(attributes)
+        @client = client
+      end
+    end
+  end
+end

data/lib/redd/models/moderatable.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Redd
+  module Models
+    # A model that can be managed by a moderator (i.e. Submissions and Comments).
+    module Moderatable
+      # Approve a submission.
+      def approve
+        client.post('/api/approve', id: read_attribute(:name))
+      end
+
+      # Remove a submission.
+      # @param spam [Boolean] whether or not this item is removed due to it being spam
+      def remove(spam: false)
+        client.post('/api/remove', id: read_attribute(:name), spam: spam)
+      end
+
+      # Distinguish a link or comment with a sigil to show that it has been created by a moderator.
+      # @param how [:yes, :no, :admin, :special, :sticky] how to distinguish the thing
+      # @note :sticky is for comments. see {Submission#make_sticky} for posts.
+      def distinguish(how = :yes)
+        params = { id: read_attribute(:name), how: how }
+        if how == :sticky
+          params[:how] = :yes
+          params[:sticky] = true
+        end
+        client.post('/api/distinguish', params)
+      end
+
+      # Remove the sigil that shows a thing was created by a moderator.
+      def undistinguish
+        distinguish(:no)
+      end
+
+      # Stop getting any moderator-related reports on the thing.
+      def ignore_reports
+        client.post('/api/ignore_reports', id: read_attribute(:name))
+      end
+
+      # Start getting moderator-related reports on the thing again.
+      def unignore_reports
+        client.post('/api/unignore_reports', id: read_attribute(:name))
+      end
+    end
+  end
+end

data/lib/redd/models/modmail.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative 'model'
+require_relative 'subreddit'
+
+module Redd
+  module Models
+    # A container for the new modmail.
+    class Modmail < Model
+      # @return [Hash<Symbol, Integer>] the number of unread messages in each category
+      def unread_count
+        client.get('/api/mod/conversations/unread/count').body
+      end
+
+      # @return [Array<Subreddit>] moderated subreddits that are enrolled in the new modmail
+      def enrolled
+        client.get('/api/mod/conversations/subreddits').body[:subreddits].map do |_, s|
+          Subreddit.new(client, s.merge(last_updated: s.delete(:lastUpdated)))
+        end
+      end
+
+      # Get the conversations
+      # @param subreddits [Subreddit, Array<Subreddit>] the subreddits to limit to
+      # @param params [Hash] additional request parameters
+      # @option params [String] :after base36 modmail conversation id
+      # @option params [Integer] :limit an integer (default: 25)
+      # @option params [:recent, :mod, :user, :unread] :sort the sort order
+      # @option params [:new, :inprogress, :mod, :notifications, :archived, :highlighted, :all]
+      #   :state the state to limit the conversations by
+      # @return [Array<ModmailConversation>] the conversations
+      def conversations(subreddits: nil, **params)
+        params[:entity] = Array(subreddits).map(&:display_name).join(',') if subreddits
+        client.get('/api/mod/conversations', **params)
+              .body[:conversations]
+              .values
+              .map { |conv| ModmailConversation.new(client, conv) }
+      end
+
+      # Create a new conversation.
+      # @param from [Subreddit] the subreddit to send the conversation from
+      # @param to [User] the person to send the message to
+      # @param subject [String] the message subject
+      # @param body [String] the message body
+      # @return [ModmailConversation] the created conversation
+      def create(from:, to:, subject:, body:, hidden: false)
+        ModmailConversation.new(client, client.post(
+          '/api/mod/conversations',
+          srName: from.display_name, to: to.name,
+          subject: subject, body: body, isAuthorHidden: hidden
+        ).body[:conversation])
+      end
+
+      # Get a conversation from its base36 id.
+      # @param id [String] the conversation's id
+      # @return [ModmailConversation]
+      def get(id)
+        ModmailConversation.new(client, id: id)
+      end
+    end
+  end
+end

data/lib/redd/models/modmail_conversation.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require 'time'
+require_relative 'model'
+
+module Redd
+  module Models
+    # Represents a conversation in the new modmail.
+    class ModmailConversation < Model
+      # Add a reply to the ongoing conversation.
+      # @param body [String] the message body (probably markdown)
+      # @param hidden [Boolean] whether the message is hidden
+      # @param internal [Boolean] whether the message is internal
+      def reply(body, hidden: false, internal: false)
+        # TODO: merge response into the conversation
+        client.post(
+          "/api/mod/conversations/#{read_attribute(:id)}",
+          body: body, isAuthorHidden: hidden, isInternal: internal
+        ).body
+      end
+
+      # Mark this conversation as read.
+      def mark_as_read
+        client.post('/api/mod/conversations/read', conversationIds: [read_attribute(:id)])
+      end
+
+      # Mark this conversation as unread.
+      def mark_as_unread
+        client.post('/api/mod/conversations/unread', conversationIds: [read_attribute(:id)])
+      end
+
+      # Mark this conversation as archived.
+      def archive
+        perform_action(:post, 'archive')
+      end
+
+      # Removed this conversation from archived.
+      def unarchive
+        perform_action(:post, 'unarchive')
+      end
+
+      # Highlight this conversation.
+      def highlight
+        perform_action(:post, 'highlight')
+      end
+
+      # Remove the highlight on this conversation.
+      def unhighlight
+        perform_action(:delete, 'highlight')
+      end
+
+      # Mute this conversation.
+      def mute
+        perform_action(:post, 'mute')
+      end
+
+      # Unmute this conversation.
+      def unmute
+        perform_action(:post, 'unmute')
+      end
+
+      # @!attribute [r] id
+      #   @return [String] the conversation id
+      property :id, :required
+
+      # @!attribute [r] messages
+      #   @return [Array<ModmailMessage>] the modmail messages
+      property :messages, with: ->(hsh) { hsh.values.map { |m| ModmailMessage.new(client, m) } }
+
+      # @!attribute [r] user
+      #   @return [Object] FIXME: details about the user the conversation deals with
+      property :user
+
+      # @!attribute [r] auto?
+      #   @return [Boolean]
+      property :auto?, from: :isAuto
+
+      # @!attribute [r] message_ids
+      #   @return [Array<String>] the conversation's message ids
+      property :message_ids, from: :objIds
+
+      # @!attribute [r] replyable?
+      #   @return [Boolean] whether you can reply to this conversation
+      property :replyable?, from: :isRepliable
+
+      # @!attribute [r] last_user_update
+      #   @return [Time] the time of last user update
+      property :last_user_update, from: :lastUserUpdate, with: ->(t) { Time.parse(t) }
+
+      # @!attribute [r] internal?
+      #   @return [Boolean]
+      property :internal?, from: :isInternal
+
+      # @!attribute [r] last_mod_update
+      #   @return [Time] the time of last mod update
+      property :last_mod_update, from: :lastModUpdate, with: ->(t) { Time.parse(t) }
+
+      # @!attribute [r] last_updated
+      #   @return [Time] the time of last update
+      property :last_updated, from: :lastUpdated, with: ->(t) { Time.parse(t) }
+
+      # @!attribute [r] authors
+      #   @return [Array<Hash>] FIXME: apply conversions
+      property :authors
+
+      # @!attribute [r] owner
+      #   @return [Hash] FIXME: do shit
+      property :owner
+
+      # @!attribute [r] highlighted?
+      #   @return [Boolean] whether the conversation is highlighted
+      property :highlighted?, from: :isHighlighted
+
+      # @!attribute [r] subject
+      #   @return [String] the conversation subject
+      property :subject
+
+      # @!attribute [r] participant
+      #   @return [Hash] FIXME: do shit
+      property :participant
+
+      # @!attribute [r] state
+      #   @return [Integer]
+      property :state
+
+      # @!attribute [r] last_unread
+      #   @return [Object]
+      property :last_unread, from: :lastUnread
+
+      # @!attribute [r] message_count
+      #   @return [Integer] the message count
+      property :message_count, from: :numMessages
+
+      private
+
+      def lazer_reload
+        fully_loaded!
+        response = client.get("/api/mod/conversations/#{read_attribute(:id)}").body
+        response[:conversation].merge(
+          messages: response[:messages],
+          user: response[:user],
+          modActions: response[:modActions]
+        )
+      end
+
+      # Perform an action on a conversation.
+      # @param method [:post, :delete] the method to use
+      # @param action [String] the name of the action
+      def perform_action(method, action)
+        client.send(method, "/api/mod/conversations/#{read_attribute(:id)}/#{action}")
+      end
+    end
+  end
+end

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