redd 0.6.5 → 0.7.0

data/lib/redd/error.rb

@@ -1,153 +1,138 @@
-module Redd
-  # An error from reddit
-  class Error < StandardError
-    attr_reader :code
-    attr_reader :headers
-    attr_reader :body
-
-    def initialize(env)
-      @code = env.status
-      @headers = env.response_headers
-      @body = env.body
-    end
-
-    class << self
-      # rubocop:disable Style/CyclomaticComplexity, Style/MethodLength
-      def from_response(response)
-        status = response[:status]
-        body = parse_error(response[:body]).to_s
-        case status
-        when 200
-          case body
-          when /ACCESS_DENIED/i
-            Redd::Error::OAuth2AccessDenied
-          when /UNSUPPORTED_RESPONSE_TYPE/i
-            Redd::Error::InvalidResponseType
-          when /UNSUPPORTED_GRANT_TYPE/i
-            Redd::Error::InvalidGrantType
-          when /INVALID_SCOPE/i
-            Redd::Error::InvalidScope
-          when /INVALID_REQUEST/i
-            Redd::Error::InvalidRequest
-          when /NO_TEXT/i
-            Redd::Error::NoTokenGiven
-          when /INVALID_GRANT/i
-            Redd::Error::ExpiredCode
-          when /WRONG_PASSWORD/i
-            Redd::Error::InvalidCredentials
-          when /BAD_CAPTCHA/i
-            Redd::Error::InvalidCaptcha
-          when /RATELIMIT/i
-            Redd::Error::RateLimited
-          when /BAD_CSS_NAME/i
-            Redd::Error::InvalidClassName
-          when /TOO_OLD/i
-            Redd::Error::Archived
-          when /TOO_MUCH_FLAIR_CSS/i
-            Redd::Error::TooManyClassNames
-          when /USER_REQUIRED/i
-            Redd::Error::AuthenticationRequired
-          end
-        when 400
-          Redd::Error::BadRequest
-        when 401
-          Redd::Error::InvalidOAuth2Credentials
-        when 403
-          case body
-          when /USER_REQUIRED/i
-            Redd::Error::AuthenticationRequired
-          else
-            Redd::Error::PermissionDenied
-          end
-        when 404
-          Redd::Error::NotFound
-        when 409
-          Redd::Error::Conflict
-        when 500
-          Redd::Error::InternalServerError
-        when 502
-          Redd::Error::BadGateway
-        when 503
-          Redd::Error::ServiceUnavailable
-        when 504
-          Redd::Error::TimedOut
-        end
-      end
-      # rubocop:enable Style/CyclomaticComplexity, Style/MethodLength
-
-      def parse_error(body)
-        return nil unless body.is_a?(Hash)
-
-        if body.key?(:json) && body[:json].key?(:errors)
-          body[:json][:errors].first
-        elsif body.key?(:jquery)
-          body[:jquery]
-        elsif body.key?(:error)
-          body[:error]
-        elsif body.key?(:code) && body[:code] == "NO_TEXT"
-          "NO_TEXT"
-        end
-      end
-    end
-
-    class NoTokenGiven < Error; end
-
-    class ExpiredCode < Error; end
-
-    class InvalidGrantType < Error; end
-
-    class InvalidOAuth2Credentials < Error; end
-
-    class OAuth2AccessDenied < Error; end
-
-    class InvalidResponseType < Error; end
-
-    class InvalidScope < Error; end
-
-    class InvalidRequest < Error; end
-
-    class AuthenticationRequired < Error; end
-
-    class InvalidCaptcha < Error; end
-
-    class BadGateway < Error; end
-
-    class BadRequest < Error; end
-
-    class InvalidMultiredditName < Error; end
-
-    class Conflict < Error; end
-
-    class InternalServerError < Error; end
-
-    class InvalidClassName < Error; end
-
-    class InvalidCredentials < Error; end
-
-    class NotFound < Error; end
-
-    class PermissionDenied < Error; end
-
-    # Raised when the client needs to wait before making another request
-    class RateLimited < Error
-      attr_reader :time
-
-      def initialize(env, time)
-        @code = env.status
-        @headers = env.response_headers
-        @body = env.body
-        @time = time
-      end
-    end
-
-    class RequestError < Error; end
-
-    class ServiceUnavailable < Error; end
-
-    class TooManyClassNames < Error; end
-
-    class Archived < Error; end
-
-    class TimedOut < Error; end
-  end
-end
+module Redd
+  # An error from reddit
+  class Error < StandardError
+    attr_reader :code
+    attr_reader :headers
+    attr_reader :body
+
+    def initialize(env)
+      @code = env[:status]
+      @headers = env[:response_headers]
+      @body = env[:body]
+    end
+
+    def self.from_response(env) # rubocop:disable all
+      status = env[:status]
+      body = parse_error(env[:body]).to_s
+      case status
+      when 200
+        case body
+        when /access_denied/i             then OAuth2AccessDenied
+        when /unsupported_response_type/i then InvalidResponseType
+        when /unsupported_grant_type/i    then InvalidGrantType
+        when /invalid_scope/i             then InvalidScope
+        when /invalid_request/i           then InvalidRequest
+        when /no_text/i                   then NoTokenGiven
+        when /invalid_grant/i             then ExpiredCode
+        when /wrong_password/i            then InvalidCredentials
+        when /bad_captcha/i               then InvalidCaptcha
+        when /ratelimit/i                 then RateLimited
+        when /bad_css_name/i              then InvalidClassName
+        when /too_old/i                   then Archived
+        when /too_much_flair_css/i        then TooManyClassNames
+        when /user_required/i             then AuthenticationRequired
+        end
+      when 400 then BadRequest
+      when 401 then InvalidOAuth2Credentials
+      when 403
+        if /user_required/i =~ body
+          AuthenticationRequired
+        else
+          PermissionDenied
+        end
+      when 404 then NotFound
+      when 409 then Conflict
+      when 500 then InternalServerError
+      when 502 then BadGateway
+      when 503 then ServiceUnavailable
+      when 504 then TimedOut
+      end
+    end
+
+    def self.parse_error(body) # rubocop:disable all
+      return body unless body.is_a?(Hash)
+
+      if body.key?(:json) && body[:json].key?(:errors)
+        body[:json][:errors].first
+      elsif body.key?(:jquery)
+        body[:jquery]
+      elsif body.key?(:error)
+        body[:error]
+      elsif body.key?(:code) && body[:code] == "NO_TEXT"
+        "NO_TEXT"
+      end
+    end
+
+    # This item has been archived and can no longer be edited.
+    Archived = Class.new(Error)
+
+    AuthenticationRequired = Class.new(Error)
+
+    # Bad Gateway. Either a network or a reddit error. Either way, try again.
+    BadGateway = Class.new(Error)
+
+    BadRequest = Class.new(Error)
+
+    Conflict = Class.new(Error)
+
+    # You already received an access token using this code. The user should
+    # grant you access again to get a new code.
+    ExpiredCode = Class.new(Error)
+
+    # There is an issue on reddit's end. Try again.
+    InternalServerError = Class.new(Error)
+
+    InvalidCaptcha = Class.new(Error)
+
+    InvalidClassName = Class.new(Error)
+
+    # Either your username or your password is wrong.
+    InvalidCredentials = Class.new(Error)
+
+    InvalidGrantType = Class.new(Error)
+
+    InvalidMultiredditName = Class.new(Error)
+
+    # Your client id or your secret is wrong.
+    InvalidOAuth2Credentials = Class.new(Error)
+
+    InvalidResponseType = Class.new(Error)
+
+    InvalidRequest = Class.new(Error)
+
+    # You don't have the proper scope to perform this request.
+    InvalidScope = Class.new(Error)
+
+    # Four, oh four! The thing you're looking for wasn't found.
+    NotFound = Class.new(Error)
+
+    # No access token was given.
+    NoTokenGiven = Class.new(Error)
+
+    OAuth2AccessDenied = Class.new(Error)
+
+    PermissionDenied = Class.new(Error)
+
+    # Raised when the client needs to wait before making another request
+    class RateLimited < Error
+      # @!attribute [r] time
+      # @return [Integer] the seconds to wait before making another request.
+      attr_reader :time
+
+      def initialize(env)
+        @time = env[:body][:json][:ratelimit]
+        super
+      end
+    end
+
+    RequestError = Class.new(Error)
+
+    # Issue on reddit's end. Try again.
+    ServiceUnavailable = Class.new(Error)
+
+    # The connection timed out. Try again.
+    TimedOut = Class.new(Error)
+
+    TooManyClassNames = Class.new(Error)
+  end
+end

data/lib/redd/objects/base.rb

@@ -0,0 +1,36 @@
+require "hashie"
+require "forwardable"
+
+module Redd
+  # A bunch of objects that can hold properties.
+  module Objects
+    # A base for all objects to inherit from.
+    class Base < Hashie::Hash
+      include Hashie::Extensions::MergeInitializer
+      include Hashie::Extensions::MethodReader
+      include Hashie::Extensions::MethodQuery
+      include Hashie::Extensions::DeepMerge
+
+      extend Forwardable
+      def_delegators :@client, :get, :post, :put, :delete
+
+      # @!attribute [r] client
+      # @return [Clients::Base] The client that used to make requests.
+      attr_reader :client
+
+      # @param [Clients::Base] client The client instance.
+      # @param [Hash] attributes A hash of attributes.
+      def initialize(client, attributes = {})
+        @client = client
+        super(attributes)
+      end
+
+      # Define an alias for a property.
+      # @param [Symbol] new_name The alias.
+      # @param [Symbol] old_name The existing property.
+      def self.alias_property(new_name, old_name)
+        define_method(new_name) { send(old_name) }
+      end
+    end
+  end
+end

data/lib/redd/objects/comment.rb

@@ -0,0 +1,22 @@
+require_relative "thing"
+
+module Redd
+  module Objects
+    # A comment that can be made on a link.
+    class Comment < Thing
+      include Thing::Editable
+      include Thing::Inboxable
+      include Thing::Moderatable
+      include Thing::Refreshable
+      include Thing::Saveable
+      include Thing::Votable
+
+      alias_property :reports_count, :num_reports
+
+      # @return [Listing] The comment's replies.
+      def replies
+        @replies ||= client.object_from_body(self[:replies])
+      end
+    end
+  end
+end

data/lib/redd/objects/listing.rb

@@ -0,0 +1,29 @@
+module Redd
+  module Objects
+    # A collection of reddit things.
+    # @see https://www.reddit.com/dev/api#listings
+    class Listing < Array
+      # @!attribute [r] before
+      # @return [String] The id of the object before the listing.
+      attr_reader :before
+
+      # @!attribute [r] after
+      # @return [String] The id of the object after the listing.
+      attr_reader :after
+
+      # @param [Clients::Base] client The client to expand the comments with.
+      # @param [{:before => String, :after => String,
+      #   :children => Array<Hash>}] attributes The data to initialize the
+      #   class with.
+      # @todo Only call Clients::Base#object_from_body when item is being
+      #   accessed.
+      def initialize(client, attributes)
+        @before = attributes[:before]
+        @after = attributes[:after]
+        attributes[:children].each do |child|
+          self << client.object_from_body(child)
+        end
+      end
+    end
+  end
+end

data/lib/redd/objects/more_comments.rb

@@ -0,0 +1,10 @@
+module Redd
+  module Objects
+    # The model for a morecomments object
+    class MoreComments < Array
+      def initialize(_, attributes)
+        super(attributes[:children])
+      end
+    end
+  end
+end

data/lib/redd/objects/private_message.rb

@@ -0,0 +1,18 @@
+require_relative "thing"
+
+module Redd
+  module Objects
+    # The model for private messages
+    class PrivateMessage < Thing
+      include Thing::Inboxable
+
+      alias_property :from, :author
+      alias_property :to, :dest
+
+      # Block the sender of the message from sending any more.
+      def block_sender!
+        post("/api/block", id: fullname)
+      end
+    end
+  end
+end

data/lib/redd/objects/submission.rb

@@ -0,0 +1,72 @@
+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
+
+      # @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
+
+      # @return [Array<Comment, MoreComments>] A linear array of the
+      #   submission's comments.
+      # @todo Somehow implement. Maybe a recursive method belonging to a
+      #   CommentListing<Comment, MoreComments>?
+      def flat_comments
+        fail NotImplementedError
+      end
+
+      # 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.
+      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
+    end
+  end
+end