redd 0.8.1 → 0.8.2

data/lib/redd/models/basic_model.rb

@@ -4,37 +4,13 @@ module Redd
   module Models
     # The base class for all models.
     class BasicModel
-      class << self
-        # @abstract Create an instance from a partial hash containing an id. The difference between
-        # this and {#initialize} is that from_response is supposed to know how to build the whole
-        # response from the partial.
-        # @param client [APIClient] the api client to initialize the object with
-        # @param hash [Hash] a partial hash
-        # @return [BasicModel]
-        def from_response(client, hash)
-          new(client, hash)
-        end
-
-        # @abstract Create an instance from a value.
-        # @param _client [APIClient] the api client to initialize the object with
-        # @param _value [Object] the object to coerce
-        # @return [BasicModel]
-        def from_id(_client, _value)
-          # TODO: abstract this out?
-          raise "coercion not implemented for #{name}"
-        end
-
-        # @return [Hash<Symbol, #from_id>] a mapping of keys to models
-        def coerced_attributes
-          @coerced_attributes ||= {}
-        end
-
-        # Mark an attribute to coerce.
-        # @param name [Symbol] the attribute to coerce
-        # @param model [#from_id, nil] a model to coerce it to
-        def coerce_attribute(name, model = nil)
-          coerced_attributes[name] = model
-        end
+      # @abstract Create an instance from a value.
+      # @param _client [APIClient] the api client to initialize the object with
+      # @param _value [Object] the object to coerce
+      # @return [BasicModel]
+      def self.from_id(_client, _value)
+        # TODO: abstract this out?
+        raise "coercion not implemented for #{name}"
       end
 
       # @return [APIClient] the client the model was initialized with
@@ -46,13 +22,11 @@ module Redd
       def initialize(client, attributes = {})
         @client = client
         @attributes = attributes
-        @to_coerce = self.class.coerced_attributes.keys
         after_initialize
       end
 
       # @return [Hash] a Hash representation of the object
       def to_h
-        coerce_all_attributes
         @attributes
       end
 
@@ -61,6 +35,11 @@ module Redd
         [self]
       end
 
+      # @return [String] an easily readable representation of the object
+      def inspect
+        "#{super}\n" + @attributes.map { |a, v| "  #{a}: #{v}" }.join("\n")
+      end
+
       # Checks whether an attribute is supported by method_missing.
       # @param method_name [Symbol] the method name or attribute to check
       # @param include_private [Boolean] whether to also include private methods
@@ -83,25 +62,6 @@ module Redd
       # @abstract Lets us plug in custom code without making a mess
       def after_initialize; end
 
-      # Coerces an attribute into a class using the {.from_id} method.
-      # @param attribute [Symbol] the attribute to coerce
-      def coerce_attribute(attribute)
-        return unless @to_coerce.include?(attribute) && @attributes.include?(attribute)
-        klass = self.class.coerced_attributes.fetch(attribute)
-        @attributes[attribute] =
-          if klass.nil?
-            @client.unmarshal(@attributes[attribute])
-          else
-            klass.from_id(@client, @attributes[attribute])
-          end
-        @to_coerce.delete(attribute)
-      end
-
-      # Coerce every attribute that can be coerced.
-      def coerce_all_attributes
-        @to_coerce.each { |a| coerce_attribute(a) }
-      end
-
       # Remove a trailing '?' from a symbol name.
       # @param method_name [Symbol] the symbol to "depredicate"
       # @return [Symbol] the symbol but with the '?' removed
@@ -113,9 +73,6 @@ module Redd
       # @param name [Symbol] the attribute to check and get
       # @return [Object] the value of the attribute
       def get_attribute(name)
-        # Coerce the attribute if it exists and needs to be coerced.
-        coerce_attribute(name) if @to_coerce.include?(name) && @attributes.key?(name)
-        # Fetch the attribute, raising a KeyError if it doesn't exist.
         @attributes.fetch(name)
       end
     end

data/lib/redd/models/comment.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'lazy_model'
+require_relative 'gildable'
 require_relative 'inboxable'
 require_relative 'moderatable'
 require_relative 'postable'
@@ -14,49 +15,44 @@ module Redd
   module Models
     # A comment.
     class Comment < LazyModel
+      include Gildable
       include Inboxable
       include Moderatable
       include Postable
       include Replyable
 
-      coerce_attribute :author, User
-      coerce_attribute :subreddit, Subreddit
-
-      # Make a Comment from its id.
-      # @option hash [String] :name the comment's fullname (e.g. t1_abc123)
-      # @option hash [String] :id the comment's id (e.g. abc123)
+      # 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_response(client, hash)
-        # FIXME: listings can be empty... (for some reason)
-
-        # Ensure we have the comment's id.
-        id = hash.fetch(:id) { hash.fetch(:name).sub('t1_', '') }
-
-        # If we have the link_id, we can load the listing with replies.
-        if hash.key?(:link_id)
-          link_id = hash[:link_id].sub('t3_', '')
-          return new(client, hash) do |c|
-            # The second half contains a single-item listing containing the comment
-            c.get("/comments/#{link_id}/_/#{id}").body[1][:data][:children][0][:data]
-          end
-        end
-
-        # We can only load the comment in isolation if we don't have the link_id.
-        new(client, hash) do |c|
-          # Returns a single-item listing containing the comment
-          c.get('/api/info', id: "t1_#{id}").body[:data][:children][0][:data]
-        end
+      def self.from_id(client, id)
+        new(client, name: id)
       end
 
       private
 
       def after_initialize
         @attributes[:replies] =
-          if !@attributes.key?(:replies) || @attributes[:replies] == ''
-            Listing.new(@client, children: [])
+          if @attributes[:replies] == ''
+            nil
           else
             @client.unmarshal(@attributes[:replies])
           end
+        @attributes[:author] = User.from_id(@client, @attributes.fetch(:author))
+        @attributes[:subreddit] = Subreddit.from_id(@client, @attributes.fetch(:subreddit))
+      end
+
+      def default_loader
+        # Ensure we have the comment's id.
+        id = @attributes.fetch(:id) { @attributes.fetch(:name).sub('t1_', '') }
+
+        # If we have the link_id, we can load the listing with replies.
+        if @attributes.key?(:link_id)
+          link_id = @attributes[:link_id].sub('t3_', '')
+          return @client.get("/comments/#{link_id}/_/#{id}").body[1][:data][:children][0][:data]
+        end
+        # We can only load the comment in isolation if we don't have the link_id.
+        @client.get('/api/info', id: "t1_#{id}").body[:data][:children][0][:data]
       end
     end
   end

data/lib/redd/models/front_page.rb

@@ -17,7 +17,7 @@ module Redd
       # @param title [String] the page's title
       # @return [WikiPage]
       def wiki_page(title)
-        WikiPage.from_response(@client, title: title)
+        WikiPage.new(@client, title: title)
       end
 
       # Get the appropriate listing.

data/lib/redd/models/gildable.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Redd
+  module Models
+    # A model that can be gilded.
+    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)}")
+      end
+    end
+  end
+end

data/lib/redd/models/inboxable.rb

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

data/lib/redd/models/lazy_model.rb

@@ -18,16 +18,10 @@ module Redd
         @definitely_fully_loaded = false
       end
 
-      # @return [Boolean] whether the model can be to be lazily initialized
-      def lazy?
-        !@lazy_loader.nil?
-      end
-
       # Force the object to make a request to reddit.
       # @return [self]
       def force_load
-        return unless lazy?
-        @attributes.merge!(@lazy_loader.call(@client))
+        @attributes.merge!(@lazy_loader ? @lazy_loader.call(@client) : default_loader)
         @definitely_fully_loaded = true
         after_initialize
         self
@@ -60,9 +54,14 @@ module Redd
 
       private
 
+      # @abstract A lazy loader to use when one is not provided.
+      def default_loader
+        {}
+      end
+
       # Make sure the model is loaded at least once.
       def ensure_fully_loaded
-        force_load if lazy? && !@definitely_fully_loaded
+        force_load unless @definitely_fully_loaded
       end
 
       # Gets the attribute and loads it if it may be available from the response.

data/lib/redd/models/listing.rb

@@ -9,13 +9,6 @@ module Redd
     class Listing < BasicModel
       include Enumerable
 
-      # Make a Listing from a basic Hash.
-      # @return [Listing]
-      def self.from_response(client, hash)
-        hash[:children].map! { |el| client.unmarshal(el) }
-        new(client, hash)
-      end
-
       # @return [Array<Comment, Submission, PrivateMessage>] an array representation of self
       def to_ary
         get_attribute(:children)
@@ -26,6 +19,12 @@ module Redd
           get_attribute(:children).public_send(method_name, *args, &block)
         end
       end
+
+      private
+
+      def after_initialize
+        @attributes.fetch(:children).map! { |el| @client.unmarshal(el) }
+      end
     end
   end
 end

data/lib/redd/models/live_thread.rb

@@ -10,19 +10,11 @@ module Redd
       # An update in a live thread.
       class LiveUpdate < BasicModel; end
 
-      # Get a Conversation from its id.
-      # @option hash [String] :id the base36 id (e.g. abc123)
-      # @return [Conversation]
-      def self.from_response(client, hash)
-        id = hash.fetch(:id)
-        new(client, hash) { |c| c.get("/live/#{id}/about").body[:data] }
-      end
-
       # Get a LiveThread from its id.
       # @param id [String] the id
       # @return [LiveThread]
       def self.from_id(client, id)
-        from_response(client, id: id)
+        new(client, id: id)
       end
 
       # Get the updates from the thread.
@@ -55,14 +47,14 @@ module Redd
       # @return [Array<User>] the contributors to this thread
       def contributors
         @client.get("/live/#{get_attribute(:id)}/contributors").body[0][:data].map do |user|
-          User.from_response(@client, user)
+          User.new(@client, user)
         end
       end
 
       # @return [Array<User>] users invited to contribute to this thread
       def invited_contributors
         @client.get("/live/#{get_attribute(:id)}/contributors").body[1][:data].map do |user|
-          User.from_response(@client, user)
+          User.new(@client, user)
         end
       end
 
@@ -77,6 +69,12 @@ module Redd
       def discussions(**params)
         @client.model(:get, "/live/#{get_attribute(:id)}/discussions", params)
       end
+
+      private
+
+      def default_loader
+        @client.get("/live/#{@attributes.fetch(:id)}/about").body[:data]
+      end
     end
   end
 end

data/lib/redd/models/mod_mail.rb

@@ -11,26 +11,11 @@ module Redd
       # Represents a conversation in the new modmail.
       # TODO: add modmail-specific user type
       class Conversation < LazyModel
-        # Get a Conversation from its id.
-        # @option hash [String] :id the base36 id (e.g. abc123)
-        # @return [Conversation]
-        def self.from_response(client, hash)
-          id = hash.fetch(:id)
-          new(client, hash) do |c|
-            response = c.get("/api/mod/conversations/#{id}").body
-            response[:conversation].merge(
-              messages: response[:messages].values.map { |m| Message.from_response(c, m) },
-              user: response[:user],
-              mod_actions: response[:modActions]
-            )
-          end
-        end
-
         # Get a Conversation from its id.
         # @param id [String] the base36 id (e.g. abc123)
         # @return [Conversation]
         def self.from_id(client, id)
-          from_response(client, id: id)
+          new(client, id: id)
         end
 
         # Add a reply to the ongoing conversation.
@@ -84,6 +69,15 @@ module Redd
 
         private
 
+        def default_loader
+          response = @client.get("/api/mod/conversations/#{@attributes[:id]}").body
+          response[:conversation].merge(
+            messages: response[:messages].values.map { |m| Message.new(@client, m) },
+            user: response[:user],
+            mod_actions: 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
@@ -104,21 +98,22 @@ module Redd
       # @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.from_response(@client, s.merge(last_updated: s.delete(:lastUpdated)))
+          Subreddit.new(@client, s.merge(last_updated: s.delete(:lastUpdated)))
         end
       end
 
       # Get the conversations
-      # @param after [String] base36 modmail conversation id
       # @param subreddits [Subreddit, Array<Subreddit>] the subreddits to limit to
-      # @param limit [Integer] an integer (default: 25)
-      # @param sort [:recent, :mod, :user, :unread] the sort order
-      # @param state [:new, :inprogress, :mod, :notifications, :archived, :highlighted, :all] the
-      #   state to limit the conversations by
+      # @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
       def conversations(subreddits: nil, **params)
         params[:entity] = Array(subreddits).map(&:display_name).join(',') if subreddits
         @client.get('/api/mod/conversations', **params).body[:conversations].map do |_, conv|
-          Conversation.from_response(@client, conv)
+          Conversation.new(@client, conv)
         end
       end
 
@@ -129,7 +124,7 @@ module Redd
       # @param body [String] the message body
       # @return [Conversation] the created conversation
       def create(from:, to:, subject:, body:, hidden: false)
-        Conversation.from_response(@client, @client.post(
+        Conversation.new(@client, @client.post(
           '/api/mod/conversations',
           srName: from.display_name, to: to.name,
           subject: subject, body: body, isAuthorHidden: hidden

data/lib/redd/models/more_comments.rb

@@ -24,7 +24,7 @@ module Redd
       # @param sort [String] the sort order of the returned comments
       # @param lookup [Hash] a hash of comments to add future replies to
       # @param depth [Number] the maximum recursion depth
-      # @return [Array<Comment, MoreComments>] the expanded comments or {self} if past depth
+      # @return [Array<Comment, MoreComments>] the expanded comments or self if past depth
       def recursive_expand(link:, sort: 'best', lookup: {}, depth: 10)
         return [self] if depth == 0
 

data/lib/redd/models/multireddit.rb

@@ -6,20 +6,12 @@ module Redd
   module Models
     # A multi.
     class Multireddit < LazyModel
-      # Make a Multireddit from its path.
-      # @option hash [String] :path the multi's path
-      # @return [Multireddit]
-      def self.from_response(client, hash)
-        path = hash.fetch(:path)
-        new(client, hash) { |c| c.get("/api/multi#{path}").body[:data] }
-      end
-
       # Create a Multireddit from its path.
       # @param client [APIClient] the api client to initialize the object with
-      # @param id [String] the multi's path (prepended by a /)
+      # @param id [String] the multi's path (with a leading and trailing slash)
       # @return [Multireddit]
       def self.from_id(client, id)
-        from_response(client, path: id)
+        new(client, path: id)
       end
 
       # Get the appropriate listing.
@@ -56,9 +48,13 @@ module Redd
       private
 
       def after_initialize
-        # @attributes[:subreddits].map! do |subreddit|
-        #   Subreddit.from_response(client, display_name: subreddit[:name])
-        # end
+        @attributes[:subreddits].map! do |subreddit|
+          Subreddit.new(client, display_name: subreddit[:name])
+        end
+      end
+
+      def default_loader
+        @client.get("/api/multi#{@attributes.fetch(:path)}").body[:data]
       end
     end
   end