neonredd 0.0.1

data/lib/redd/objects/submission.rb

@@ -0,0 +1,140 @@
+require_relative 'thing'
+
+module Redd
+  module Objects
+    # A submission made in a subreddit.
+    class Submission < Thing
+      include Thing::Editable
+      include Thing::Hideable
+      include Thing::Moderatable
+      include Thing::Refreshable
+      include Thing::Saveable
+      include Thing::Votable
+
+      alias_property :nsfw?, :over_18
+      alias_property :self?, :is_self
+      alias_property :comments_count, :num_comments
+
+      # The shorter url for sharing.
+      def short_url
+        "http://redd.it/#{self[:id]}"
+      end
+
+      # Whether the comment was gilded.
+      def gilded?
+        self[:gilded] > 0
+      end
+
+      # Mark the thing as Not Suitable For Work.
+      def mark_as_nsfw
+        get('/api/marknsfw', id: fullname)
+        self[:over_18] = true
+      end
+
+      # No longer mark the thing as Not Suitable For Work.
+      def unmark_as_nsfw
+        get('/api/unmarknsfw', id: fullname)
+        self[:over_18] = false
+      end
+      alias mark_as_safe unmark_as_nsfw
+
+      # Reply to the thing.
+      # @param text [String] The text to comment.
+      # @return [Objects::Comment] The reply.
+      def add_comment(text)
+        client.add_comment(self, text)
+      end
+
+      # Set the submission to "contest mode" (comments are randomly sorted)
+      def set_contest_mode
+        post('/api/set_contest_mode', id: fullname, state: true)
+      end
+
+      # Unset the "contest mode".
+      def unset_contest_mode
+        post('/api/set_contest_mode', id: fullname, state: false)
+      end
+
+      # Set the submission as the sticky post of the subreddit
+      def set_sticky
+        post('/api/set_subreddit_sticky', id: fullname, state: true)
+        self[:stickied] = true
+      end
+
+      # Unsticky the post from the subreddit
+      def unset_sticky
+        post('/api/set_subreddit_sticky', id: fullname, state: false)
+        self[:stickied] = false
+      end
+
+      # @return [Listing] The submission's comments.
+      # @todo Allow for various depths and contexts and what not. Maybe a
+      #   get_comment method?
+      def comments
+        refresh! unless @comments
+        @comments
+      end
+      alias replies comments
+
+      # Refresh the submission AND its comments.
+      # @return [Submission] The updated submission.
+      def refresh!
+        body = get("/comments/#{id}.json").body
+        @comments = client.object_from_body(body[1])
+        deep_merge!(body[0])
+      end
+
+      # Take a MoreComments and return a listing of comments.
+      # @param [MoreComments] more The object to expand.
+      # @return [Listing] A listing of the expanded comments.
+      # rubocop:disable Metrics/MethodLength
+      def expand_more(more)
+        response = client.get(
+          '/api/morechildren',
+          children: more.join(','),
+          link_id: fullname
+        )
+
+        client.object_from_body(
+          kind: 'Listing',
+          data: {
+            before: '', after: '',
+            children: response.body[:json][:data][:things]
+          }
+        )
+      end
+
+      # Get the related articles.
+      # @param [Hash] params 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 [Objects::Listing<Objects::Thing>]
+      def get_related(**params)
+        related = get("/related/#{id}.json", params).body[1]
+        client.object_from_body(related)
+      end
+
+      # Get other articles with the same URL.
+      # @param [Hash] params 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 [Objects::Listing<Objects::Submission>]
+      def get_duplicates(**params)
+        duplicates = get("/duplicates/#{id}.json", params).body[1]
+        client.object_from_body(duplicates)
+      end
+    end
+  end
+end

data/lib/redd/objects/subreddit.rb

@@ -0,0 +1,329 @@
+require 'fastimage'
+require_relative 'thing'
+# rubocop:disable Metrics/ClassLength, Metrics/ParameterLists
+# rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+module Redd
+  module Objects
+    # A comment made on links.
+    # @todo #subscribe! and #unsubscribe!
+    class Subreddit < Thing
+      include Thing::Messageable
+      include Thing::Refreshable
+
+      alias_property :header_image, :header_img
+      alias_property :nsfw?, :over18
+      alias_property :users_online, :accounts_active
+      alias_property :type, :subreddit_type
+      alias_property :times_gilded, :gilded
+
+      # @!group Submissions
+
+      # Submit a link or a text post to the subreddit.
+      #
+      # @param [String] title The title of the submission.
+      # @param [String] captcha A possible captcha result to send if one
+      #   is required.
+      # @param [String] identifier The identifier for the captcha if one
+      #   is required.
+      # @param [String] text The text of the self-post.
+      # @param [String] url The URL of the link.
+      # @param [Boolean] resubmit Whether to post a link to the subreddit
+      #   despite it having been posted there before (you monster).
+      # @param [Boolean] sendreplies Whether to send the replies to your
+      #   inbox.
+      # @return [Objects::Thing] The returned result (url, id and name).
+      def submit(
+        title, captcha = nil, identifier = nil, text: nil, url: nil,
+        resubmit: false, sendreplies: true
+      )
+
+        params = {
+          extension: 'json', title: title, sr: display_name,
+          resubmit: resubmit, sendreplies: sendreplies
+        }
+
+        if captcha
+          params[:captcha] = captcha
+          params[:iden] = identifier
+        end
+        if text
+          params[:kind] = :self
+          params[:text] = text
+        end
+        if url
+          params[:kind] = :link
+          params[:url] = url
+        end
+
+        response = post('/api/submit', params)
+        Objects::Thing.new(self, response.body[:json][:data])
+      end
+
+      # Add a comment to the submission.
+      # @param text [String] The text to comment.
+      # @return [Objects::Comment] The reply.
+      def add_comment(text)
+        client.add_comment(self, text)
+      end
+
+      # @!endgroup
+
+      # @!group Stylesheets
+
+      # @return [String] The url for the subreddit's stylesheet.
+      def stylesheet_url
+        get("/r/#{display_name}/stylesheet").headers['location']
+      end
+
+      # @return [String] The css for the subreddit.
+      def stylesheet
+        Faraday.get(stylesheet_url).body
+      end
+
+      # Edit the subreddit's stylesheet
+      #
+      # @param [String] contents The new CSS.
+      # @param [String] reason Why you modified the stylesheet.
+      # @author Takashi M (@beatak) and Avinash Dwarapu (@avidw)
+      # @note https://www.reddit.com/r/naut/about/stylesheet/ is a good place
+      #   to test if you have an error.
+      def edit_stylesheet(contents, reason = nil)
+        params = { op: 'save', stylesheet_contents: contents }
+        params[:reason] = reason if reason
+        post("/r/#{display_name}/api/subreddit_stylesheet", params)
+      end
+
+      # @!endgroup
+
+      # @!group Invites
+
+      # Accept a moderator invite from a subreddit.
+      def accept_moderator_invite!
+        post("/r/#{display_name}/api/accept_moderator_invite")
+      end
+
+      # Stop being a contributor of the subreddit.
+      def leave_contributor_status!
+        post('/api/leavecontributor', id: fullname)
+      end
+
+      # Stop being a moderator of the subreddit.
+      def leave_moderator_status!
+        post('/api/leavemoderator', id: fullname)
+      end
+
+      # @!endgroup
+
+      # @!group Flairs
+
+      # Get a list of everbody on the subreddit with a user flair.
+      #
+      # @param [Hash] params 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..1000] :limit The maximum number of things to
+      #   return.
+      # @option params [String] :name The username when getting the flair of
+      #   just one user.
+      # @return [Objects::Listing<Hash>] A listing of flair hashes.
+      def get_flairlist(**params)
+        body = get("/r/#{display_name}/api/flairlist.json", params).body
+        client.object_from_body(
+          kind: 'Listing',
+          data: {
+            children: body[:users],
+            before: body[:prev],
+            after: body[:next]
+          }
+        )
+      end
+
+      # Get the flair of a user.
+      #
+      # @param [Objects::User, String] user The user to find.
+      # @return [Hash, nil] Flair info about the user or nil if nobody was
+      #   found.
+      def get_flair(user)
+        username = client.property(user, :name)
+        flair = get_flairlist(user: username).first
+        flair if flair[:user].casecmp(username) == 0
+      end
+
+      # Set the flair of a user or link.
+      # @param [Objects::Subreddit, Objects::User] thing The user or link to
+      #   set the flair to.
+      # @param [:user, :link] type The type of thing.
+      # @param [String] text The text to set the flair to.
+      # @param [String] css_class The css_class of the flair.
+      def set_flair(thing, type = nil, text = nil, css_class = nil)
+        params = { text: text, css_class: css_class }
+        if thing.is_a?(Objects::User) || type == :user
+          params[:name] = client.property(thing, :name)
+        elsif thing.is_a?(Objects::Submission) || type == :link
+          params[:link] = client.property(thing, :fullname)
+        else
+          fail 'You should provide a proper type.'
+        end
+
+        post("/r/#{display_name}/api/flair", params)
+      end
+
+      # @!endgroup
+
+      # @!group Listings
+
+      # @!method get_hot(**params)
+      # @!method get_new(**params)
+      # @!method get_top(**params)
+      # @!method get_controversial(**params)
+      # @!method get_comments(**params)
+      #
+      # Get the appropriate 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 (0) The number of items already seen
+      #   in the listing.
+      # @option params [1..100] :limit (25) The maximum number of things to
+      #   return.
+      # @option params [:hour, :day, :week, :month, :year, :all] :t The
+      #   time period to consider when sorting.
+      #
+      # @note The option :t only applies to the top and controversial sorts.
+      # @return [Objects::Listing<Objects::Thing>]
+      %w(hot new top controversial comments).each do |sort|
+        define_method :"get_#{sort}" do |**params|
+          client.send(:"get_#{sort}", self, **params)
+        end
+      end
+
+      # Search.
+      # @param query [String] The query string.
+      # @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 [:cloudsearch, :lucene, :plain] :syntax The type of
+      #   syntax to use.
+      # @option params [:relevance, :new, :hot, :top, :comments] :sort The
+      #   way to sort the results.
+      # @option params [:hour, :day, :week, :month, :year, :all] :t The
+      #   time period to consider when sorting.
+      #
+      # @note The option :t only applies to the top and controversial sorts.
+      # @return [Objects::Listing<Objects::Thing>]
+      def search(query, **params)
+        client.search(query, self, **params)
+      end
+
+      # @!endgroup
+
+      # @!group Moderation
+
+      # @!method get_reports(**params)
+      # @!method get_spam(**params)
+      # @!method get_modqueue(**params)
+      # @!method get_unmoderated(**params)
+      # @!method get_edited(**params)
+      #
+      # Get the appropriate moderator listing.
+      # @param [Hash] params 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 :location No idea what this does.
+      # @option params [:links, :comments] :only The type of things to show.
+      #
+      # @return [Objects::Listing<Objects::Thing>]
+      # @see https://www.reddit.com/dev/api#GET_about_{location}
+      %w(reports spam modqueue unmoderated edited).each do |sort|
+        define_method :"get_#{sort}" do |**params|
+          client.request_object(
+            :get, "/r/#{display_name}/about/#{sort}", params
+          )
+        end
+      end
+
+      # @return [Objects::Base] The current settings of a subreddit.
+      def admin_about
+        client.request_object(:get, "/r/#{display_name}/about/edit.json")
+      end
+
+      # Edit the subreddit's settings
+      # @param [Hash] attributes The subreddit's new settings.
+      # @note This method may make additional requests if not all of the
+      #   required attributes are provided. Take a look at the source for the
+      #   required attributes required to avoid making the additional request.
+      # @see https://github.com/alaycock/MeetCal-bot/blob/master/serverInfo.conf
+      def admin_edit(attributes)
+        params = {
+          # Subreddit name
+          sr: fullname,
+          # Apparently useless options
+          show_cname_sidebar: true,
+          :"header-title" => title
+        }
+
+        required = %i(
+          allow_top collapse_deleted_comments comment_score_hide_mins
+          css_on_cname description exclude_banned_modqueue lang link_type name
+          over_18 public_description public_traffic show_media spam_comments
+          spam_links spam_selfposts submit_link_label submit_text
+          submit_text_label title type wiki_edit_age wiki_edit_karma wikimode
+        )
+
+        if required.all? { |key| attributes.key?(key) }
+          params.merge!(attributes)
+        else
+          about = admin_about
+          final = about
+                  .select { |k, _| required.include?(k) }
+                  .merge(
+                    name: display_name,
+                    type: about[:subreddit_type],
+                    lang: about[:language],
+                    link_type: about[:content_options],
+                    allow_top: true,
+                    css_on_cname: true
+                  )
+                  .merge(attributes)
+          params.merge!(final)
+        end
+
+        post('/api/site_admin', params)
+      end
+
+      # Add or replace the subreddit image or header logo.
+      # @param [String, IO] file The path/url to the file or the file itself.
+      # @param [String] name The name of the uploaded file.
+      # @return [String] The url of the image on reddit's CDN.
+      def upload_image(file, name = nil)
+        io = (file.is_a?(IO) ? file : File.open(file, 'r'))
+        type = FastImage.type(io)
+        payload = Faraday::UploadIO.new(io, "image/#{type}")
+
+        params = { file: payload, header: (name ? 0 : 1), img_type: type }
+        params[:name] = name if name
+        post("/r/#{display_name}/api/upload_sr_img", params).body[:img_src]
+      end
+
+      # @!endgroup
+    end
+  end
+end

data/lib/redd/objects/thing/editable.rb

@@ -0,0 +1,22 @@
+module Redd
+  module Objects
+    class Thing
+      # Things that can be edited and deleted.
+      module Editable
+        # Edit a thing.
+        # @param text [String] The new text.
+        # @return [Thing] The edited thing.
+        def edit(text)
+          post('/api/editusertext', thing_id: fullname, text: text)
+          self[(is_a?(Submission) ? :selftext : :body)] = text
+          self
+        end
+
+        # Delete the thing
+        def delete!
+          post('/api/del', id: fullname)
+        end
+      end
+    end
+  end
+end

data/lib/redd/objects/thing/hideable.rb

@@ -0,0 +1,18 @@
+module Redd
+  module Objects
+    class Thing
+      # Things that can be hidden from the user.
+      module Hideable
+        # Hide a link from the user.
+        def hide
+          post('/api/hide', id: fullname)
+        end
+
+        # Unhide a previously hidden link.
+        def unhide
+          post('/api/unhide', id: fullname)
+        end
+      end
+    end
+  end
+end

data/lib/redd/objects/thing/inboxable.rb

@@ -0,0 +1,25 @@
+module Redd
+  module Objects
+    class Thing
+      # Things that can be sent to a user's inbox.
+      module Inboxable
+        # Mark this thing as read.
+        def mark_as_read
+          post('/api/read_message', id: fullname)
+        end
+
+        # Mark one or more messages as unread.
+        def mark_as_unread
+          post('/api/unread_message', id: fullname)
+        end
+
+        # Reply to the thing.
+        # @param text [String] The text to comment.
+        # @return [Objects::Comment, Objects::PrivateMessage] The reply.
+        def reply(text)
+          client.add_comment(self, text)
+        end
+      end
+    end
+  end
+end

data/lib/redd/objects/thing/messageable.rb

@@ -0,0 +1,38 @@
+module Redd
+  module Objects
+    class Thing
+      # Things that can be sent a message.
+      module Messageable
+        # Compose a message to a person or the moderators of a subreddit.
+        #
+        # @param [String] subject The subject of the message.
+        # @param [String] text The message text.
+        # @param [String] from_sr The subreddit to send the message on behalf
+        #   of or nil if from the user.
+        # @param [String] captcha A possible captcha result to send if one
+        #   is required.
+        # @param [String] identifier The identifier for the captcha if one
+        #   is required.
+        # rubocop:disable Metrics/MethodLength
+        def send_message(
+          subject, text, from_sr = nil, captcha = nil, identifier = nil
+        )
+          params = { subject: subject, text: text }
+          if captcha
+            params[:captcha] = captcha
+            params[:iden] = identifier
+          end
+          params[:from_sr] = client.property(from_sr, :display_name) if from_sr
+          params[:to] =
+            if respond_to?(:display_name)
+              "/r/#{self[:display_name]}"
+            else
+              self[:name]
+            end
+
+          post('/api/compose', params)
+        end
+      end
+    end
+  end
+end

data/lib/redd/objects/thing/moderatable.rb

@@ -0,0 +1,43 @@
+module Redd
+  module Objects
+    class Thing
+      # Things that a moderator can manage.
+      module Moderatable
+        # Approve a submission.
+        def approve!
+          post('/api/approve', id: fullname)
+        end
+
+        # Remove a submission.
+        # @param [Boolean] spam Whether or not this item is removed due to it
+        #   being spam.
+        def remove!(spam = false)
+          post('/api/remove', id: fullname, spam: spam)
+        end
+
+        # Distinguish a link or comment with a sigil to show that it has
+        # been created by a moderator.
+        # @param [:yes, :no, :admin, :special] how How to distinguish the
+        #   thing.
+        def distinguish(how = :yes)
+          post('/api/distinguish', id: fullname, how: how)
+        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
+          post('/api/ignore_reports', id: fullname)
+        end
+
+        # Start getting moderator-related reports on the thing again.
+        def unignore_reports
+          post('/api/unignore_reports', id: fullname)
+        end
+      end
+    end
+  end
+end

data/lib/redd/objects/thing/refreshable.rb

@@ -0,0 +1,14 @@
+module Redd
+  module Objects
+    class Thing
+      # Things that can be refreshed with the current data.
+      module Refreshable
+        # Refresh the thing.
+        def refresh!
+          body = get('/api/info', id: fullname).body[:data][:children][0]
+          deep_merge!(body[:data])
+        end
+      end
+    end
+  end
+end

data/lib/redd/objects/thing/saveable.rb

@@ -0,0 +1,21 @@
+module Redd
+  module Objects
+    class Thing
+      # Things that can be saved to a user's account.
+      module Saveable
+        # Save a link or comment (if gilded) to the user's account.
+        # @param [String] category A category to save to (if gilded).
+        def save(category = nil)
+          params = { id: fullname }
+          params[:category] = category if category
+          post('/api/save', params)
+        end
+
+        # Remove the link or comment from the user's saved links.
+        def unsave
+          post('/api/unsave', id: fullname)
+        end
+      end
+    end
+  end
+end

data/lib/redd/objects/thing/votable.rb

@@ -0,0 +1,33 @@
+module Redd
+  module Objects
+    class Thing
+      # Things that can be voted upon.
+      module Votable
+        # Upvote the thing.
+        def upvote
+          vote(1)
+        end
+
+        # Downvote the thing.
+        def downvote
+          vote(-1)
+        end
+
+        # Remove your vote on the thing.
+        def clear_vote
+          vote(0)
+        end
+        alias unvote clear_vote
+
+        private
+
+        # Send a vote.
+        # @param [-1, 0, 1] direction The direction to vote in.
+        def vote(direction)
+          post('/api/vote', id: fullname, dir: direction)
+          self[:ups] += direction
+        end
+      end
+    end
+  end
+end