redd 0.8.8 → 0.9.0.pre.1

data/lib/redd/models/replyable.rb

@@ -8,8 +8,8 @@ module Redd
       # @param text [String] the text to comment
       # @return [Comment, PrivateMessage] The created reply.
       def reply(text)
-        fullname = get_attribute(:name)
-        @client.model(:post, '/api/comment', text: text, thing_id: fullname).first
+        fullname = read_attribute(:name)
+        client.model(:post, '/api/comment', text: text, thing_id: fullname).first
       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

@@ -25,9 +25,9 @@ module Redd
         if params[:restrict_to]
           subreddit = params.delete(:restrict_to)
           params[:restrict_sr] = true
-          @client.model(:get, "/r/#{subreddit}/search", params)
+          client.model(:get, "/r/#{subreddit}/search", params)
         else
-          @client.model(:get, '/search', params)
+          client.model(:get, '/search', params)
         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

data/lib/redd/models/session.rb

@@ -1,83 +1,108 @@
 # frozen_string_literal: true
 
-require_relative 'lazy_model'
+require_relative 'model'
 require_relative 'searchable'
 
 module Redd
   module Models
     # The starter class.
-    class Session < BasicModel
+    class Session < Model
       include Searchable
 
-      # @return [ModMail] the new modmail
-      def mod_mail
-        ModMail.new(@client)
+      # @return [Modmail] the new modmail
+      def modmail
+        Modmail.new(client)
       end
 
       # @return [LiveThread] the live thread
       def live_thread(id)
-        LiveThread.from_id(client, id)
+        LiveThread.new(client, id: id)
       end
 
       # @return [FrontPage] the user's front page
       def front_page
-        FrontPage.new(@client)
+        FrontPage.new(client)
       end
 
       # @return [Hash] a breakdown of karma over subreddits
       def karma_breakdown
-        @client.get('/api/v1/me/karma').body[:data]
+        client.get('/api/v1/me/karma').body[:data]
       end
 
       # @return [User] the logged-in user
       def me
-        User.new(@client) { |client| client.get('/api/v1/me').body }
+        Self.new(client)
       end
 
       # Get a (lazily loaded) reddit user by their name.
       # @param name [String] the username
       # @return [User]
       def user(name)
-        User.from_id(@client, name)
+        User.new(client, name: name)
+      end
+
+      # Returns whether a username is available.
+      # @param username [String] the username to check
+      # @return [Boolean] whether the username is available
+      def username_available?(username)
+        client.get('/api/username_available', user: username).body
       end
 
       # Get a (lazily loaded) subreddit by its name.
       # @param display_name [String] the subreddit's display name
       # @return [Subreddit]
       def subreddit(display_name)
-        Subreddit.from_id(@client, display_name)
+        Subreddit.new(client, display_name: display_name)
       end
 
       # @return [Array<Multireddit>] array of multireddits belonging to the user
       def my_multis
-        @client.get('/api/multi/mine').body.map { |m| @client.unmarshal(m) }
+        client.get('/api/multi/mine').body.map { |m| client.unmarshal(m) }
       end
 
       # Get a (lazily loaded) multi by its path.
       # @param path [String] the multi's path, surrounded by a leading and trailing /
       # @return [Multireddit]
       def multi(path)
-        Multireddit.from_id(@client, path)
+        Multireddit.new(client, path: path)
       end
 
       # Get submissions or comments by their fullnames.
       # @param fullnames [String, Array<String>] one or an array of fullnames (e.g. t3_abc1234)
       # @return [Listing<Submission, Comment>]
-      def from_ids(fullnames)
-        # XXX: Could we use better methods for t1_ and t3_?
-        @client.model(:get, '/api/info', id: Array(fullnames).join(','))
+      # @deprecated Try the lazier {#from_fullnames} instead.
+      def from_ids(*fullnames)
+        client.model(:get, '/api/info', id: fullnames.join(','))
+      end
+
+      # Create lazily-loaded objects from their fullnames (e.g. t1_abc123).
+      # @param fullnames [String] fullname for a submission, comment, or subreddit.
+      # @return [Array<Submission, Comment, User, Subreddit>]
+      def from_fullnames(*fullnames)
+        fullnames.map do |name|
+          if name.start_with?('t1_')
+            Comment.new(client, name: name)
+          elsif name.start_with?('t3_')
+            Submission.new(client, name: name)
+          elsif name.start_with?('t5_')
+            Subreddit.new(client, name: name)
+          else
+            raise "unknown fullname #{name}"
+          end
+        end
       end
 
       # Get submissions or comments by their fullnames.
       # @param url [String] the object's url
       # @return [Submission, Comment, nil] the object, or nil if not found
       def from_url(url)
-        @client.model(:get, '/api/info', url: url).first
+        client.model(:get, '/api/info', url: url).first
       end
 
       # Return a listing of the user's inbox (including comment replies and private messages).
       #
-      # @param category ['inbox', 'unread', 'sent', 'moderator'] the category of messages to view
+      # @param category ['inbox', 'unread', 'sent', 'moderator', 'messages'] the category of
+      #   messages to view
       # @param mark [Boolean] whether to remove the orangered from the user's inbox
       # @param params [Hash] a list of optional params to send with the request
       # @option params [String] :after return results after the given fullname
@@ -86,17 +111,17 @@ module Redd
       # @option params [1..100] :limit (25) the maximum number of things to return
       # @return [Listing<Comment, PrivateMessage>]
       def my_messages(category: 'inbox', mark: false, **params)
-        @client.model(:get, "/message/#{category}.json", params.merge(mark: mark))
+        client.model(:get, "/message/#{category}.json", params.merge(mark: mark))
       end
 
       # Mark all messages as read.
       def read_all_messages
-        @client.post('/api/read_all_messages')
+        client.post('/api/read_all_messages')
       end
 
       # @return [Hash] the user's preferences
       def my_preferences
-        @client.get('/api/v1/me/prefs').body
+        client.get('/api/v1/me/prefs').body
       end
 
       # Edit the user's preferences.
@@ -104,7 +129,7 @@ module Redd
       # @return [Hash] the new preferences
       # @see #my_preferences
       def edit_preferences(new_prefs = {})
-        @client.request(
+        client.request(
           :patch, '/api/v1/me/prefs',
           headers: { 'Content-Type' => 'application/json' },
           body: JSON.generate(new_prefs)
@@ -113,28 +138,28 @@ module Redd
 
       # @return [Array<User>] the logged-in user's friends
       def friends
-        @client.get('/api/v1/me/friends').body[:data][:children].map do |h|
-          User.new(@client, name: h[:name], id: h[:id].sub('t2_', ''), since: h[:date])
+        client.get('/api/v1/me/friends').body[:data][:children].map do |h|
+          User.new(client, name: h[:name], id: h[:id].sub('t2_', ''), since: h[:date])
         end
       end
 
       # @return [Array<User>] users blocked by the logged-in user
       def blocked
-        @client.get('/prefs/blocked').body[:data][:children].map do |h|
-          User.new(@client, name: h[:name], id: h[:id].sub('t2_', ''), since: h[:date])
+        client.get('/prefs/blocked').body[:data][:children].map do |h|
+          User.new(client, name: h[:name], id: h[:id].sub('t2_', ''), since: h[:date])
         end
       end
 
-      # @return [Array<User>] users blocked by the logged-in user
+      # @return [Array<User>] users trusted by the logged-in user
       def trusted
-        @client.get('/prefs/trusted').body[:data][:children].map do |h|
-          User.new(@client, name: h[:name], id: h[:id].sub('t2_', ''), since: h[:date])
+        client.get('/prefs/trusted').body[:data][:children].map do |h|
+          User.new(client, name: h[:name], id: h[:id].sub('t2_', ''), since: h[:date])
         end
       end
 
       # @return [Array<String>] a list of categories the user's items are saved in
       def saved_categories
-        @client.get('/api/saved_categories').body
+        client.get('/api/saved_categories').body
       end
 
       # Return a listing of the user's subreddits.
@@ -147,7 +172,26 @@ module Redd
       # @option params [1..100] :limit (25) the maximum number of things to return
       # @return [Listing<Subreddit>]
       def my_subreddits(type, **params)
-        @client.model(:get, "/subreddits/mine/#{type}", params)
+        client.model(:get, "/subreddits/mine/#{type}", params)
+      end
+
+      # Return trending subreddits.
+      # @return [Hash]
+      # @example
+      #   session.trending_subreddits
+      #   => {
+      #     "subreddit_names": [
+      #       "AskLibertarians",
+      #       "OpTicGaming",
+      #       "Cuphead",
+      #       "AlmostParkour",
+      #       "TheGoodPlace"
+      #     ],
+      #     "comment_count": 176,
+      #     "comment_url": "/r/trendingsubreddits/comments/73dkin/trending_subreddits_for_20170930_rasklibertarians/"
+      #   }
+      def trending_subreddits
+        client.get('/api/trending_subreddits').body
       end
     end
   end

data/lib/redd/models/submission.rb

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
 
-require_relative 'lazy_model'
+require_relative 'model'
 require_relative 'gildable'
 require_relative 'moderatable'
 require_relative 'postable'
 require_relative 'replyable'
+require_relative 'reportable'
 
 require_relative 'user'
 require_relative 'subreddit'
@@ -12,36 +13,19 @@ require_relative 'subreddit'
 module Redd
   module Models
     # A text or link post.
-    class Submission < LazyModel
+    class Submission < Model
       include Gildable
       include Moderatable
       include Postable
       include Replyable
+      include Reportable
 
-      # Create a Subreddit from its fullname.
-      # @param client [APIClient] the api client to initialize the object with
-      # @param id [String] the fullname
-      # @return [Submission]
-      def self.from_id(client, id)
-        new(client, name: id)
-      end
-
-      # @return [Symbol] the requested sort order
-      def sort_order
-        @sort_order ||= nil
-      end
-
-      # Set the sort order of the comments and reload if necessary.
+      # Set the sort order of the comments and reload the comments.
       # @param new_order [:confidence, :top, :controversial, :old, :qa] the sort order
-      def sort_order=(new_order)
-        # If the comments were loaded in a different sort order, delete them and invalidate this
-        # model.
-        if @attributes.key?(:comments) && @sort_order != new_order
-          @attributes.delete(:comments)
-          @definitely_fully_loaded = false
-        end
-
-        @sort_order = new_order
+      def update_sort_order(new_order)
+        return self if new_order == read_attribute(:sort_order)
+        write_attribute(:sort_order, new_order)
+        reload
       end
 
       # Get all submissions for the same url.
@@ -52,94 +36,363 @@ module Redd
       # @option params [1..100] :limit (25) the maximum number of things to return
       # @return [Listing<Submission>]
       def duplicates(**params)
-        @client.unmarshal(@client.get("/duplicates/#{get_attribute(:id)}", params).body[1])
+        client.unmarshal(client.get("/duplicates/#{read_attribute(:id)}", params).body[1])
       end
 
       # Mark the link as "Not Suitable For Work".
       def mark_as_nsfw
-        @client.get('/api/marknsfw', id: get_attribute(:name))
-        @attributes[:over_18] = true
+        client.get('/api/marknsfw', id: read_attribute(:name))
       end
 
       # No longer mark the link as "Not Suitable For Work".
       def unmark_as_nsfw
-        @client.get('/api/unmarknsfw', id: get_attribute(:name))
-        @attributes[:over_18] = false
+        client.get('/api/unmarknsfw', id: read_attribute(:name))
       end
 
       # Mark the link as a spoiler.
       def mark_as_spoiler
-        @client.get('/api/spoiler', id: get_attribute(:name))
-        @attributes[:spoiler] = true
+        client.get('/api/spoiler', id: read_attribute(:name))
       end
 
       # No longer mark the link as a spoiler.
       def unmark_as_spoiler
-        @client.get('/api/unspoiler', id: get_attribute(:name))
-        @attributes[:spoiler] = false
+        client.get('/api/unspoiler', id: read_attribute(:name))
       end
 
       # Set the submission to "contest mode" (comments are randomly sorted)
       def enable_contest_mode
-        @client.post('/api/set_contest_mode', id: get_attribute(:name), state: true)
+        client.post('/api/set_contest_mode', id: read_attribute(:name), state: true)
       end
 
       # Disable the "contest mode".
       def disable_contest_mode
-        @client.post('/api/set_contest_mode', id: get_attribute(:name), state: false)
+        client.post('/api/set_contest_mode', id: read_attribute(:name), state: false)
       end
 
       # Set the submission as the sticky post of the subreddit.
       # @param slot [1, 2] which "slot" to place the sticky on
       def make_sticky(slot: nil)
-        @client.post('/api/set_subreddit_sticky', id: get_attribute(:name), num: slot, state: true)
+        client.post('/api/set_subreddit_sticky', id: read_attribute(:name), num: slot, state: true)
       end
 
       # Unsticky the post from the subreddit.
       def remove_sticky
-        @client.post('/api/set_subreddit_sticky', id: get_attribute(:name), state: false)
+        client.post('/api/set_subreddit_sticky', id: read_attribute(:name), state: false)
       end
 
       # Prevent users from commenting on the link (and hide it as well).
       def lock
-        @client.post('/api/lock', id: get_attribute(:name))
+        client.post('/api/lock', id: read_attribute(:name))
       end
 
       # Allow users to comment on the link again.
       def unlock
-        @client.post('/api/unlock', id: get_attribute(:name))
+        client.post('/api/unlock', id: read_attribute(:name))
       end
 
       # Set the suggested sort order for comments for all users.
       # @param suggested ['blank', 'confidence', 'top', 'new', 'controversial', 'old', 'random',
       #   'qa', 'live'] the sort type
-      def set_suggested_sort(suggested) # rubocop:disable Style/AccessorMethodName
-        # Style/AccessorMethodName is disabled because it feels wrong for accessor methods to make
-        # HTTP requests.
-        @client.post('/api/set_suggested_sort', id: get_attribute(:name), sort: suggested)
+      def set_suggested_sort(suggested) # rubocop:disable Naming/AccessorMethodName
+        client.post('/api/set_suggested_sort', id: read_attribute(:name), sort: suggested)
       end
 
+      # @!attribute [r] sort_order
+      #   @return [Symbol] the comment sort order
+      property :sort_order, :nil
+
+      # @!attribute [r] comments
+      #   @return [Array<Comment>] the comment tree
+      property :comments, :nil, with: ->(l) { Listing.new(client, l) if l }
+
+      # @!attribute [r] domain
+      #   @return [String] the domain name of the link (or self.subreddit_name)
+      property :domain
+
+      # @!attribute [r] approved_at
+      #   @return [Time, nil] when the submission was last approved
+      property :approved_at, :approved_at_utc, with: ->(t) { Time.at(t) if t }
+
+      # @!attribute [r] banned_by
+      #   @return [String] not sure what this does
+      property :banned_by
+
+      # @!attribute [r] media_embed
+      #   @return [Hash] media embed properties
+      property :media_embed
+
+      # @!attribute [r] subreddit
+      #   @return [Subreddit] the subreddit the post belongs to.
+      property :subreddit, with: ->(n) { Subreddit.new(client, display_name: n) }
+
+      # @!attribute [r] selftext_html
+      #   @return [String, nil] the html-rendered self text, can be nil if link
+      property :selftext_html
+
+      # @!attribute [r] selftext
+      #   @return [String] the self text contents
+      property :selftext
+
+      # @!attribute [r] upvoted?
+      #   @return [Boolean, nil] whether the user upvoted/downvoted this post
+      property :upvoted?, from: :likes
+
+      # @!attribute [r] suggested_sort
+      #   @return [String, nil] the suggested sort
+      property :suggested_sort
+
+      # @!attribute [r] user_reports
+      #   @return [Array<String>] user reports
+      property :user_reports
+
+      # @!attribute [r] secure_media
+      #   @return [Hash, nil] secure media details
+      property :secure_media
+
+      # @!attribute [r] link_flair_text
+      #   @return [String] the link flair text
+      property :link_flair_text
+
+      # @!attribute [r] link_flair_css_class
+      #   @return [String] the link flair css class
+      property :link_flair_css_class
+
+      # @!attribute [r] id
+      #   @return [String] the submission id
+      property :id
+
+      # @!attribute [r] banned_at
+      #   @return [Time, nil] the time the post was banned
+      property :banned_at, from: :banned_at_utc, with: ->(t) { Time.at(t) if t }
+
+      # @!attribute [r] view_count
+      #   @return [Integer, nil] the view count
+      property :view_count
+
+      # @!attribute [r] archived?
+      #   @return [Boolean] whether the post is archived
+      property :archived?, from: :archived
+
+      # @!attribute [r] clicked?
+      #   @return [Boolean] whether the post was clicked
+      property :clicked?, from: :clicked
+
+      # @!attribute [r] report_reasons
+      #   @return [Object] i think it's an array of strings?
+      property :report_reasons
+
+      # @!attribute [r] title
+      #   @return [String] the post title
+      property :title
+
+      # @!attribute [r] num_crossposts
+      #   @return [Integer] the number of crossposts made to other subreddits
+      property :num_crossposts
+
+      # @!attribute [r] saved?
+      #   @return [String] whether the post was saved by the logged-in user
+      property :saved?, from: :saved
+
+      # @!attribute [r] can_mod_post?
+      #   @return [Boolean] whether you can post as a mod, i think
+      property :can_mod_post?, from: :can_mod_post
+
+      # @!attribute [r] crosspostable?
+      #   @return [Boolean] whether the post can be crossposted
+      property :crosspostable?, from: :is_crosspostable
+
+      # @!attribute [r] pinned?
+      #   @return [Boolean] whether the post is pinned
+      property :pinned?, from: :pinned
+
+      # @!attribute [r] score
+      #   @return [Integer] the post's score
+      property :score
+
+      # @!attribute [r] approved_by
+      #   @return [Object] the person that approved this post (not sure about the schema)
+      property :approved_by
+
+      # @!attribute [r] over_18?
+      #   @return [Boolean] whether the post is marked as over 18
+      property :over_18?, from: :over_18
+
+      # @!attribute [r] hidden?
+      #   @return [Boolean] whether the logged-in user hid the post
+      property :hidden?, from: :hidden
+
+      # @!attribute [r] preview
+      #   @return [Hash] preview details
+      property :preview
+
+      # @!attribute [r] comment_count
+      #   @return [Integer] the post's comment count
+      property :comment_count, from: :num_comments
+
+      # @!attribute [r] thumbnail
+      #   @return [String] the thumbnail url
+      property :thumbnail
+
+      # @!attribute [r] thumbnail_height
+      #   @return [Integer] thumbnail height
+      property :thumbnail_height
+
+      # @!attribute [r] score_hidden?
+      #   @return [Boolean] whether the score is hidden
+      property :score_hidden?, from: :hide_score
+
+      # @!attribute [r] edited
+      #   @return [Time, false] the time of the last edit
+      property :edited, with: ->(t) { Time.at(t) if t }
+
+      # @!attribute [r] author_flair_text
+      #   @return [String] the author flair text
+      property :author_flair_text
+
+      # @!attribute [r] author_flair_css_class
+      #   @return [String] the author flair css class
+      property :author_flair_css_class
+
+      # @!attribute [r] contest_mode_enabled?
+      #   @return [Boolean] whether contest mode is turned on
+      property :contest_mode_enabled?, from: :contest_mode
+
+      # @!attribute [r] gilded
+      #   @return [Integer] the number of times the post was gilded
+      property :gilded
+
+      # @!attribute [r] locked?
+      #   @return [Boolean] whether the post is locked
+      property :locked?, from: :locked
+
+      # @!attribute [r] ups
+      #   @return [Integer] upvote count
+      #   @deprecated this doesn't return the raw upvote count - use {#score} instead
+      property :ups
+
+      # @!attribute [r] downs
+      #   @return [Integer] downvote count
+      #   @deprecated this always returns zero - use {#score} instead
+      property :downs
+
+      # @!attribute [r] brand_safe?
+      #   @return [Boolean] whether the post is marked as brand safe
+      property :brand_safe?, from: :brand_safe
+
+      # @!attribute [r] secure_media_embed
+      #   @return [Hash] secure media embed details
+      property :secure_media_embed
+
+      # @!attribute [r] removal_reason
+      #   @return [String] the removal reason
+      property :removal_reason
+
+      # @!attribute [r] post_hint
+      #   @return [String] a hint at what the link should contain
+      property :post_hint
+
+      # @!attribute [r] can_gild?
+      #   @return [Boolean] whether the user can gild this post
+      property :can_gild?, from: :can_gild
+
+      # @!attribute [r] parent_whitelist_status
+      #   @return [String] ad-related whitelist stuff
+      property :parent_whitelist_status
+
+      # @!attribute [r] name
+      #   @return [String] the fullname (i.e. t3_xxxxxx)
+      property :name
+
+      # @!attribute [r] spoiler?
+      #   @return [Boolean] whether the post was marked as a spoiler
+      property :spoiler?, from: :spoiler
+
+      # @!attribute [r] permalink
+      #   @return [String] the **relative** url permalink
+      property :permalink
+
+      # @!attribute [r] report_count
+      #   @return [Integer] the number of reports
+      property :report_count, from: :num_reports
+
+      # @!attribute [r] whitelist_status
+      #   @return [String] ad-related whitelist stuff
+      property :whitelist_status
+
+      # @!attribute [r] stickied?
+      #   @return [Boolean] whether the post was stickied
+      property :stickied?, from: :stickied
+
+      # @!attribute [r] url
+      #   @return [String] the link url
+      property :url
+
+      # @!attribute [r] quarantined?
+      #   @return [Boolean] whether the post has been quarantined
+      property :quarantined?, from: :quarantine
+
+      # @!attribute [r] author
+      #   @return [User] the post author
+      property :author, with: ->(n) { User.new(client, name: n) }
+
+      # @!attribute [r] created_at
+      #   @return [Time] creation time
+      property :created_at, from: :created_utc, with: ->(t) { Time.at(t) }
+
+      # @!attribute [r] subreddit_name_prefixed
+      #   @return [String] r/[subreddit name]
+      property :subreddit_name_prefixed,
+               default: ->() { "r/#{read_attribute(:subreddit).display_name}" }
+
+      # @!attribute [r] distinguished?
+      #   @return [Boolean] whether the post is distinguished
+      property :distinguished?, from: :distinguished
+
+      # @!attribute [r] media
+      #   @return [Hash] media details
+      property :media
+
+      # @!attribute [r] upvote_ratio
+      #   @return [Float] the upvote ratio (ups/downs)
+      property :upvote_ratio
+
+      # @!attribute [r] mod_reports
+      #   @return [Array] moderator reports
+      property :mod_reports
+
+      # @!attribute [r] self?
+      #   @return [Boolean] whether the post is a self post
+      property :self?, from: :is_self
+
+      # @!attribute [r] visited?
+      #   @return [Boolean] whether the post was visited
+      property :visited?, from: :visited
+
+      # @!attribute [r] subreddit_type
+      #   @return [String] the subreddit's type
+      property :subreddit_type
+
+      # @!attribute [r] video?
+      #   @return [Boolean] whether the post is probably a video
+      property :video, from: :is_video
+
       private
 
-      def default_loader
+      def lazer_reload
+        fully_loaded!
+
         # Ensure we have the link's id.
-        id = @attributes[:id] ? @attributes[:id] : @attributes.fetch(:name).sub('t3_', '')
+        id = self[:id] ? read_attribute(:id) : read_attribute(:name).sub('t3_', '')
+
         # If a specific sort order was requested, provide it.
         params = {}
-        params[:sort] = @sort_order if @sort_order
+        params[:sort] = read_attribute(:sort_order) if self[:sort_order]
 
         # `response` is a pair (2-element array):
         #   - response[0] is a one-item listing containing the submission
         #   - response[1] is listing of comments
-        response = @client.get("/comments/#{id}", params).body
-        response[0][:data][:children][0][:data].merge(comments: @client.unmarshal(response[1]))
-      end
-
-      def after_initialize
-        if @attributes[:subreddit]
-          @attributes[:subreddit] = Subreddit.from_id(@client, @attributes[:subreddit])
-        end
-        @attributes[:author] = User.from_id(@client, @attributes[:author]) if @attributes[:author]
+        response = client.get("/comments/#{id}", params).body
+        response[0][:data][:children][0][:data].merge(comments: response[1][:data])
       end
     end
   end