reddit_api 0.1.18 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fff7c79ae95004afc62a96034a80d48fdb33d9c5
-  data.tar.gz: 00e2b4d24fe666eb5bc55a885073dcaf56089c75
+  metadata.gz: e2c1a49844a77703602af21827434a0d54f4db28
+  data.tar.gz: d59933c5bbeb7b06c38bf1319c99ed6e343317e8
 SHA512:
-  metadata.gz: 731f3fa32a0fdf3d3a832b54fdcc300e29046f1a303e68cd59192154b8aa4642689a116d9efdbfffa184b9de77d4cdb462f898887a0790ade90427f7b5670d45
-  data.tar.gz: bc467855c109fa8eb474fdd58f6d42bef2e1127da3e66bedd0d16138f550df981bba3c0f9132735b0787562d0e47dbcb6a2c47021af2e373bb956935c9a3a7c5
+  metadata.gz: 6a631d30ae80980cab7ba975181c0e015da0abe7a98004f317f435fc99c92630c9cb93cddb063899f291cc4cd18b78cf032e64826c3f19a5506b9b012a1738d1
+  data.tar.gz: 7ff3eda53055f62798f0344de7debca41da2e541806248d007ae0e9450f8a2ce0434c8872b5956909215ae0f186b132dc2c40c7634b193dab9982578ebc6c59e

data/lib/reddit_api/client.rb

@@ -11,117 +11,59 @@ module RedditApi
       end
     end
 
-    attr_reader :agent, :id, :password, :secret, :username, :failures
-
-    MAX_FAILURES = 5
-    ERROR_CODES = (400..511)
     SLEEP_TIME = self.sleep_time
+    MAX_FAILURES = 5
+
+    attr_reader :failures
 
     def initialize(args = {})
       @client = args.fetch(:client, HTTParty)
       @requestor = args.fetch(:requestor, RedditApi::Requestor.new(client: client))
-      @failures = args.fetch(:failures, 0)
+      @parser = args.fetch(:parser, RedditApi::ResponseParser)
       @null_response_factory = RedditApi:: NullResponse
-      @last_record = nil
+      @failures = args.fetch(:failures, 0)
     end
 
-    def get(endpoint, count, resource_type, offset = nil)
-      if count > 1
-        get_many(endpoint, count, resource_type, offset)
-      else
-        get_one(endpoint, count, resource_type)
+    def get(query)
+      while query.capture_count < query.count && failures < MAX_FAILURES
+        response = send_request(query)
+        response = parser.parse_response(response, query.count)
+        update_progress(query, response)
       end
+      reset_failures
     end
 
     protected
-    attr_writer :failures, :last_record
+    attr_writer :failures
     private
-    attr_reader :client, :base_url, :null_response_factory, :last_record,
-                :requestor
+    attr_reader :client, :null_response_factory, :requestor, :parser
 
-    def get_many(endpoint, count, resource_type, offset)
+    def send_request(query)
       sleep(SLEEP_TIME)
-      records = {}
-      self.last_record = offset
-      while !break_get?(records, count)
-        new_records = request_records(endpoint, count, resource_type)
-        collect_records(new_records, records, count)
-      end
-      after_collection
-      records.keys
-    end
-
-    def get_one(endpoint, count, resource_type)
-      request_records(endpoint, count, resource_type)
-    end
-
-    def request_records(endpoint, count, resource_type)
-      response = send_request(endpoint, resource_type)
-      parse_response(response, count)
-    end
-
-    def collect_records(new_records, collected_records, count)
-      new_records.each do |record|
-        collected_records[record] = true
-        break if collected_records.length == count
-      end
-    end
-
-    def after_collection
-      self.last_record = nil
-      self.failures = 0
-    end
-
-    def send_request(endpoint, resource_type)
-      request = requestor.build(endpoint, resource_type, last_record)
+      request = requestor.build(query)
       response = client.get(*request)
       response || null_response_factory.new
     end
 
-    def parse_response(response, count)
-      if bad_response?(response)
-        handle_bad_response(count)
-      else
-        handle_successful_response(response, count)
-      end
+    def update_progress(query, response)
+      captured_before = query.capture_count
+      update_query(query, response)
+      captured_after = query.capture_count
+      update_failures(captured_before, captured_after, query.count)
     end
 
-    def bad_response?(response)
-      ERROR_CODES.cover?(response.code) || response["error"]
+    def update_query(query, response)
+      query.add_records(response)
     end
 
-    def handle_bad_response(count)
-      self.failures += 1
-      if count > 1
-        []
-      else
-        nil
+    def update_failures(captured_before, captured_after, count)
+      if captured_before >= captured_after
+        self.failures += 1
       end
     end
 
-    def handle_successful_response(response, count)
-      if count > 1
-        handle_plural_response(response)
-      else
-        response
-      end
-    end
-
-    def handle_plural_response(response)
-      if records = response["data"]["children"]
-        store_last_record(records)
-      else
-        handle_bad_response
-      end
-    end
-
-    def store_last_record(records)
-      self.last_record = records[-1]
-      records
-    end
-
-    def break_get?(records, desired_count)
-      records.length >= desired_count || failures >= MAX_FAILURES
+    def reset_failures
+      self.failures = 0
     end
 
   end

data/lib/reddit_api/comments.rb

@@ -7,6 +7,7 @@ module RedditApi
     def initialize(args = {})
       @client = args.fetch(:client, RedditApi::Client.new)
       @comment_factory = RedditApi::Comment
+      @query_factory =  RedditApi::Query
       @offset = nil
       @failures = 0
     end
@@ -26,7 +27,7 @@ module RedditApi
       subreddits.keys
     end
 
-    def most_recent_comments(user, count = 100, offset = nil)
+    def most_recent_comments(user, count, offset = nil)
       comments_data = most_recent_comment_data(user.username, count, offset)
       build_all_comments(comments_data)
     end
@@ -35,7 +36,22 @@ module RedditApi
     attr_accessor :failures
     attr_writer :offset, :failures
     private
-    attr_reader :client, :comment_factory, :offset
+    attr_reader :client, :comment_factory, :offset, :query_factory
+
+    def most_recent_comment_data(username, count, offset)
+      return [] if username == "[deleted]"
+      query = build_query(username, count, offset)
+      client.get(query)
+      query.captured_records
+    end
+
+    def build_query(username, count, offset)
+      endpoint = "user/#{username}/comments.json"
+      query_factory.new(count: count,
+                        endpoint: endpoint,
+                        resource: :comment,
+                        offset: offset)
+    end
 
     def update_progress(comments)
       if comments.empty?
@@ -45,12 +61,6 @@ module RedditApi
       end
     end
 
-    def most_recent_comment_data(username, count, offset)
-      return [] if username == "[deleted]"
-      endpoint = "user/#{username}/comments.json"
-      client.get(endpoint, count, :comment, offset)
-    end
-
     def build_all_comments(comments_data)
       comments_data.map! do |comment_data|
         build_comment(comment_data)

data/lib/reddit_api/posts.rb

@@ -5,6 +5,7 @@ module RedditApi
     def initialize
       @client = RedditApi::Client.new
       @post_factory = RedditApi::Post
+      @query_factory =  RedditApi::Query
     end
 
     def top(subreddit, count)
@@ -14,11 +15,19 @@ module RedditApi
     end
 
     private
-    attr_reader :client, :post_factory
+    attr_reader :client, :post_factory, :query_factory
 
     def top_data(subreddit, count)
+      query = build_query(subreddit, count)
+      client.get(query)
+      query.captured_records
+    end
+
+    def build_query(subreddit, count)
       endpoint = URI.encode("r/#{subreddit.name}/hot.json")
-      client.get(endpoint, count, :post)
+      query_factory.new(count: count,
+                        endpoint: endpoint,
+                        resource: :post)
     end
 
     def filter_out(posts_data, filter)

data/lib/reddit_api/query.rb

@@ -0,0 +1,56 @@
+
+module RedditApi
+  class Query
+
+    attr_reader :count, :endpoint, :offset_id, :resource_type
+
+    def initialize(args = {})
+      @count = args.fetch(:count)
+      @endpoint = args.fetch(:endpoint, "")
+      @offset_id = args.fetch(:offset, "")
+      @records = args.fetch(:records, {})
+      @resource_type = args.fetch(:resource, "")
+    end
+
+    def add_records(new_records)
+      if count > 1
+        add_multiple_records(new_records)
+      else
+        add_single_record(new_records)
+      end
+    end
+
+    def captured_records
+      records.values
+    end
+
+    def capture_count
+      records.length
+    end
+
+    protected
+    attr_writer :offset_id
+    private
+    attr_reader :records
+
+    def add_multiple_records(new_records)
+      new_records.each do |record|
+        record_id = record["data"]["id"]
+        records[record_id] = record
+        update_offset_id(record_id)
+        break if records.length == count
+      end
+    end
+
+    def add_single_record(record)
+      record_id = record["id"]
+      records[record_id] = record
+      update_offset_id(record_id)
+    end
+
+    def update_offset_id(record_id)
+      self.offset_id = record_id
+    end
+
+  end
+end

data/lib/reddit_api/requestor.rb

@@ -2,66 +2,54 @@
 module RedditApi
   class Requestor
 
-    MAXIMUM_RECORDS = 100
-
     def initialize(args = {})
-      @client = args.fetch(:client, HTTParty)
       @agent = ENV["REDDIT_AGENT"]
+      @base_url = "https://oauth.reddit.com/"
+      @client = args.fetch(:client, HTTParty)
       @id = ENV["REDDIT_ID"]
       @password = ENV["REDDIT_PASSWORD"]
       @secret = ENV["REDDIT_SECRET"]
       @username = ENV["REDDIT_USERNAME"]
-      @base_url = "https://oauth.reddit.com/"
     end
 
-    def build(endpoint, resource_type, last_record = nil)
-      url = base_url + endpoint
+    def build(query)
+      url = base_url + query.endpoint
       headers = generate_headers
-      query = generate_query(resource_type, last_record)
-      [url, { headers: headers, query: query }]
+      api_query = generate_query(query)
+      [url, { headers: headers, query: api_query }]
     end
 
     private
-    attr_reader :agent, :base_url, :id, :password, :secret, :username, :client
+    attr_reader :agent, :base_url, :client, :id, :password, :secret, :username
 
     def generate_headers
-      access_token = generate_access_token
       {
         "Authorization" => "bearer #{access_token}",
         "user-agent" => agent
       }
     end
 
-    def generate_query(resource_type, last_record)
+    def generate_query(query)
       {
-        limit: MAXIMUM_RECORDS,
-        after: generate_after(resource_type, last_record)
+        limit: query.count,
+        after: generate_after(query.resource_type, query.offset_id)
       }
     end
 
-    def generate_after(resource_type, last_record)
-      if last_record
-        build_after(resource_type, last_record)
+    def generate_after(resource_type, offset_id)
+      if offset_id
+        build_after(resource_type, offset_id)
       else
         ""
       end
     end
 
-    def build_after(resource_type, record)
+    def build_after(resource_type, offset_id)
       prefix = TYPE_PREFIXES[resource_type]
-      last_resource_id = record_id(record)
-      "#{prefix}_#{last_resource_id}"
-    end
-
-    def record_id(record)
-      if record.is_a?(Hash)
-        record["data"]["id"]
-      else
-        record
-      end
+      "#{prefix}_#{offset_id}"
     end
 
-    def generate_access_token
+    def access_token
       url = "https://www.reddit.com/api/v1/access_token"
       basic_auth = { username: id,
                      password: secret }

data/lib/reddit_api/response_parser.rb

@@ -0,0 +1,48 @@
+
+module RedditApi
+  module ResponseParser
+    class << self
+
+      ERROR_CODES = (400..511)
+
+      def parse_response(response, count)
+        if bad_response?(response)
+          handle_bad_response(count)
+        else
+          handle_successful_response(response, count)
+        end
+      end
+
+      private
+
+      def bad_response?(response)
+        ERROR_CODES.cover?(response.code) || response["error"]
+      end
+
+      def handle_bad_response(count)
+        if count > 1
+          []
+        else
+          {}
+        end
+      end
+
+      def handle_successful_response(response, count)
+        if count > 1
+          handle_plural_response(response)
+        else
+          handle_singular_response(response)
+        end
+      end
+
+      def handle_plural_response(response)
+        response["data"]["children"]
+      end
+
+      def handle_singular_response(response)
+        response["data"]
+      end
+
+    end
+  end
+end

data/lib/reddit_api/subreddits.rb

@@ -5,6 +5,7 @@ module RedditApi
     def initialize
       @client = RedditApi::Client.new
       @subreddit_factory = RedditApi::Subreddit
+      @query_factory =  RedditApi::Query
     end
 
     def top(count)
@@ -13,27 +14,42 @@ module RedditApi
     end
 
     def data_for(subreddit)
-      endpoint = "r/#{subreddit.name}/about.json"
-      response = client.get(endpoint, 1, :subreddit)
-      build_subreddit(response)
+      query = build_singular_query(subreddit)
+      client.get(query)
+      build_subreddit(query.captured_records.first)
     end
 
     private
-    attr_reader :client, :subreddit_factory
+    attr_reader :client, :subreddit_factory, :query_factory
 
     def top_data(count)
+      query = build_plural_query(count)
+      client.get(query)
+      query.captured_records
+    end
+
+    def build_plural_query(count)
       endpoint = "subreddits/popular.json"
-      client.get(endpoint, count, :subreddit)
+      query_factory.new(count: count,
+                        endpoint: endpoint,
+                        resource: :subreddit)
+    end
+
+    def build_singular_query(subreddit)
+      endpoint = "r/#{subreddit.name}/about.json"
+      query_factory.new(count: 1,
+                        endpoint: endpoint,
+                        resource: :subreddit)
     end
 
     def build_all_subreddits(subreddits_data)
       subreddits_data.map! do |subreddit_data|
-        build_subreddit(subreddit_data)
+        build_subreddit(subreddit_data["data"])
       end
     end
 
     def build_subreddit(subreddit_data)
-      subreddit_factory.new(subreddit_data["data"])
+      subreddit_factory.new(subreddit_data)
     end
 
   end

data/lib/reddit_api/version.rb

@@ -1,3 +1,3 @@
 module RedditApi
-  VERSION = "0.1.18"
+  VERSION = "0.2.0"
 end

data/lib/reddit_api.rb

@@ -2,7 +2,9 @@ require "reddit_api/version"
 require "dotenv/load"
 require "reddit_api/null_response"
 require "reddit_api/resource_type_prefixes"
+require "reddit_api/query"
 require "reddit_api/requestor"
+require "reddit_api/response_parser"
 require "reddit_api/client"
 require "reddit_api/subreddits"
 require "reddit_api/subreddit"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: reddit_api
 version: !ruby/object:Gem::Version
-  version: 0.1.18
+  version: 0.2.0
 platform: ruby
 authors:
 - Anthony Fuentes
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-02-20 00:00:00.000000000 Z
+date: 2017-02-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dotenv
@@ -149,8 +149,10 @@ files:
 - lib/reddit_api/null_response.rb
 - lib/reddit_api/post.rb
 - lib/reddit_api/posts.rb
+- lib/reddit_api/query.rb
 - lib/reddit_api/requestor.rb
 - lib/reddit_api/resource_type_prefixes.rb
+- lib/reddit_api/response_parser.rb
 - lib/reddit_api/subreddit.rb
 - lib/reddit_api/subreddits.rb
 - lib/reddit_api/user.rb