reddit-api 0.1.1

data/exe/reddit-api

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+require "reddit/api"

data/lib/reddit/api.rb

@@ -0,0 +1,14 @@
+require "reddit/api/version"
+# Require External Libs
+require "json"
+require "pry"
+require "rest-client"
+require "log4r"
+
+# Require Internal Files
+require "reddit/internal/logger"
+require "reddit/internal/processor"
+require "reddit/internal/connection"
+
+require "reddit/services"
+require "reddit/services/user"

data/lib/reddit/api/version.rb

@@ -0,0 +1,5 @@
+module Reddit
+  module Api
+    VERSION = "0.1.1"
+  end
+end

data/lib/reddit/internal/connection.rb

@@ -0,0 +1,143 @@
+module Reddit
+  module Internal
+    class Connection
+
+      # User Information
+      attr_accessor :username
+      attr_accessor :password
+      attr_accessor :client_id
+      attr_accessor :secret
+      attr_accessor :user_agent_title
+
+      # Token Info
+      attr_accessor :token
+      attr_accessor :token_expiration
+
+      # Rate Limiting Info
+      attr_accessor :request_throttle
+      attr_accessor :requests_per_minute
+      attr_reader :last_request_time
+
+      # Retry Info
+      attr_accessor :max_retries
+
+      # Creates a new connection
+      def initialize(username, password, client_id, secret, user_agent_title, request_throttle: nil, max_retries: nil)
+
+        # Set up the module
+        @username = username
+        @password = password
+        @client_id = client_id
+        @secret = secret
+        @user_agent_title = user_agent_title
+        @token = nil
+
+        @request_throttle = request_throttle == nil ? true : false
+        @requests_per_minute = 60
+        @last_request_time = Time.now.to_f
+
+        @max_retries = max_retries ||= 3
+
+        at_exit do
+          self.sign_out()
+        end
+      end
+
+
+      # Signs In A User, Making The Connection Active
+      def sign_in()
+
+        Reddit::Internal::Logger.log.debug "Signing In User #{@username} with client_id #{@client_id}..."
+        response = JSON.parse(RestClient::Request.execute(method: :post,
+                                                          url: "https://www.reddit.com/#{Reddit::Services::REFERENCE["Auth"]["access_token"]["url"]}",
+                                                          payload: "grant_type=password&username=#{@username}&password=#{@password}",
+                                                          user: @client_id, password: @secret))
+
+
+        Reddit::Internal::Logger.log.debug "Sign In Response:"
+        Reddit::Internal::Logger.log.debug JSON.pretty_generate(response)
+
+        raise "Error Invalid Credentials" if response.include?("error")
+
+        @token_expiration = Time.now.to_f + response["expires_in"]
+        @token = response["access_token"]
+
+        Reddit::Internal::Logger.log.info "Sign In Retrieved Token: #{@token}"
+        return @token
+      end
+
+
+      # Signs Out A User, Killing the connection
+      def sign_out()
+        if @token
+          Reddit::Internal::Logger.log.debug "Signing Out User #{@username} with client_id #{@client_id}..."
+          response = RestClient::Request.execute(method: :post,
+                                                 url: "https://www.reddit.com/#{Reddit::Services::REFERENCE["Auth"]["revoke_token"]["url"]}",
+                                                 payload: "token=#{@token}",
+                                                user: @client_id, password: @secret)
+
+          Reddit::Internal::Logger.log.debug "Sign Out Response: #{response}"
+
+          Reddit::Internal::Logger.log.info "Signed Out User #{@username}"
+          @token = nil
+        else
+
+        end
+      end
+
+      # Refreshes a token (BROKEN? 400 bad request, possibly due to token still being valid...)
+      def refresh()
+        Reddit::Internal::Logger.log.debug "Refreshing Token For User #{@username} with client_id #{@client_id}"
+        response = JSON.parse(RestClient::Request.execute(method: :post,
+                                                          url: "https://www.reddit.com/#{Reddit::Services::REFERENCE["Auth"]["access_token"]["url"]}",
+                                                          payload: "grant_type=refresh_token&refresh_token=#{@token}",
+                                                          user: @client_id, password: @secret))
+
+        Reddit::Internal::Logger.log.debug "Refresh Response:"
+        Reddit::Internal::Logger.log.debug JSON.pretty_generate(response)
+
+        return response
+      end
+
+
+      # Handles Requests From This Users Auth
+      def request(method, url, payload)
+
+        raise "User Not Signed In!" unless @token
+
+        refresh() if @token_expiration < Time.now.to_f
+
+        Reddit::Internal::Logger.log.debug "Reqest From User #{@username}, method: #{method}, url: #{url}"
+
+        if @request_throttle
+          Reddit::Internal::Logger.log.debug "Request Throttling Enabled, Processing Request at #{Time.now.to_f}, Last Call: #{@last_request_time}..."
+          request_wait_time = @requests_per_minute / 60
+          next_avaliable = @last_request_time + request_wait_time
+          if Time.now.to_f < next_avaliable
+            sleep_time = (next_avaliable - Time.now.to_f)
+            Reddit::Internal::Logger.log.info "Rate Limiter Sleeping For #{sleep_time}"
+            sleep sleep_time
+          end
+        end
+
+        # Handle getting a new token if we expired...
+
+        retries = @max_retries
+        begin
+          response = JSON.parse(RestClient::Request.execute(method: method, url: url, payload: payload,
+                                                            headers: {"Authorization" => "bearer #{token}", "User-Agent" => "ruby-reddit-api:#{user_agent_title}"} ))
+        rescue StandardError => e
+          retry unless (retries -= 1).zero?
+          raise e
+        end
+        Reddit::Internal::Logger.log.debug "Request Response:"
+        Reddit::Internal::Logger.log.debug JSON.pretty_generate(response)
+
+        @last_request_time = Time.now.to_f
+        return response
+      end
+
+
+    end
+  end
+end

data/lib/reddit/internal/logger.rb

@@ -0,0 +1,17 @@
+module Reddit
+  module Internal
+    module Logger
+      extend self
+
+      attr_accessor :log
+      attr_accessor :enable_file_logging
+      @enable_file_logging = false
+
+      @log = Log4r::Logger.new("reddit_api.log")
+      @log.outputters << Log4r::FileOutputter.new("reddit_api.log", filename: "reddit_api.log") if @enable_file_logging
+      @log.outputters << Log4r::Outputter.stdout
+
+      @log.level = Log4r::WARN 
+    end
+  end
+end

data/lib/reddit/internal/processor.rb

@@ -0,0 +1,90 @@
+module Reddit
+  module Internal
+    module Processor
+      extend self
+
+      attr_accessor :base_url
+      @base_url = "https://oauth.reddit.com/"
+
+
+      def process(module_name, function_name, user, payload, var_hash)
+        ref_data = Reddit::Services::REFERENCE[module_name][function_name.split("_").drop(1).join("/")]
+
+
+        # URL Building
+        if ref_data["fields"].include?("basepath_subreddit")
+          raise "Basepath Subreddit Required But Not Passed!" unless var_hash[:basepath_subreddit]
+          # Subreddit Exception (As its not listed in the json file)
+          url = "#{@base_url}r/#{var_hash[:basepath_subreddit]}/#{ref_data["url"]}"
+        else
+          url = "#{@base_url}#{ref_data["url"]}"
+        end
+
+
+        # Url Basepath
+        var_hash.each do |k,v|
+          if k.to_s.include?("basepath_") && !k.to_s.include?("basepath_subreddit")
+            url.gsub!(k.to_s.split("_").drop(1).join("_"), v)
+          end
+        end
+
+        # Url Params
+        url += "?" + var_hash.collect { |k,v| "#{k.to_s}=#{v.to_s}" unless k.to_s.include?("basepath_") }.join("&") if var_hash.length > var_hash.select{|k,v| k.to_s.include?("basepath_")}.length
+
+
+        # Make the request via the user
+        user.connection.request(ref_data["method"], url, payload)
+      end
+
+
+      def batch_call(module_name, function_name, user, var_hash)
+        #Setup Local Vars
+        page_size = var_hash[:page_size]
+        max_size = var_hash[:max_size]
+        remove_sticky = var_hash[:remove_sticky]
+
+        remove_sticky = true if remove_sticky == nil
+
+        raise "page_size parameter missing!" unless page_size
+        raise "max_size parameter missing!" unless max_size
+        raise "page_size cannot be zero!" if page_size == 0
+
+        # Delete Paging Specific Hash Set
+        var_hash.delete(:page_size)
+        var_hash.delete(:max_size)
+        var_hash.delete(:remove_sticky)
+
+        # Set up our out of loop variables
+        total_results = []
+        last_entry = nil
+
+        # Process Requests
+        Reddit::Internal::Logger.log.debug "Processing Batch #{module_name} -> #{function_name}:"
+        (max_size / page_size).times do |index|
+          Reddit::Internal::Logger.log.debug "Batch [#{index} / #{(max_size / page_size)}]"
+          # Setup Vars For Local Batch
+          page_var_hash = var_hash ? var_hash : {}
+          page_var_hash["after"] = last_entry if last_entry
+          page_var_hash["count"] = index * page_size
+          page_var_hash["limit"] = page_size
+
+          # Fetch Batch
+          result_batch = Reddit::Internal::Processor.process(module_name, function_name, user, nil, page_var_hash)
+          result_batch = result_batch["data"]["children"]
+
+          # Remove Extra Sticky Posts
+          result_batch = result_batch.drop(result_batch.length - page_size) unless last_entry if remove_sticky
+
+          # Merge Results
+          total_results += result_batch
+
+          # Check if break / setup for next set.
+          break if result_batch.length < page_size
+          last_entry = result_batch.last["data"]["name"]
+        end
+        return total_results
+      end
+
+    end
+  end
+end

data/lib/reddit/services.rb

@@ -0,0 +1,54 @@
+module Reddit
+  module Services
+    extend self
+    Reddit::Internal::Logger.log.debug "Loading REFERENCE."
+    REFERENCE = JSON.parse(File.read(File.expand_path("../../../data/reddit_api.json", __FILE__)))
+    Reddit::Internal::Logger.log.debug "REFERENCE Loaded."
+
+    private
+    # Generates a given function
+    def generate_function(new_module, module_name, hash)
+      # Generate our Get and Post Functions
+      method_name = "#{hash["method"]}_#{hash["name"].split("/").join("_")}"
+
+      Reddit::Internal::Logger.log.debug "Generating Funcgion #{module_name}.#{method_name}"
+
+      if hash["method"] == "post"
+        new_module.define_singleton_method(method_name) do |user, payload, options = {}|
+          Reddit::Internal::Processor.process(module_name, method_name, user, payload, options)
+        end
+      else
+        new_module.define_singleton_method(method_name) do |user, options = {}|
+          Reddit::Internal::Processor.process(module_name, method_name, user, nil, options)
+        end
+      end
+
+      #Generate Print Function
+      print_name = "print_#{method_name}"
+      new_module.define_singleton_method(print_name) do
+        Reddit::Internal::Logger.debug "Fields: #{REFERENCE[module_name][hash["name"]]["fields"]}"
+        REFERENCE[module_name][hash["name"]]["fields"]
+      end
+
+      # Generate the batch functions on GET endpoints for listings (As other endpoints tend to output different data formats)
+      if hash["method"] == "get" && module_name == :Listings
+        batch_name = "batch_#{hash["name"].split("/").join("_")}"
+        new_module.define_singleton_method(batch_name) do |user, options = {}|
+          Reddit::Internal::Processor.batch_call(module_name, method_name, user, options)
+        end
+      end
+    end
+
+    # Itterate through the given JSON and generate modules and functions
+    REFERENCE.each do |api_module, module_functions|
+      Reddit::Internal::Logger.log.debug "Generating Module: #{api_module}"
+      new_module = Module.new do
+        module_functions.each do |name, function_hash|
+          Reddit::Services.send(:generate_function, self, api_module, function_hash)
+        end
+      end
+      Reddit::Services.const_set(api_module, new_module)
+      Reddit::Internal::Logger.log.debug "Generating Module: #{api_module} Completed."
+    end
+  end
+end

data/lib/reddit/services/user.rb

@@ -0,0 +1,23 @@
+module Reddit
+  module Services
+    # Everything else in the services module is created at runtime through the "service.rb" generator
+
+    class User
+
+      attr_accessor :name
+      attr_accessor :token
+
+      attr_accessor :connection
+
+      def initialize(username, password, client_id, secret, user_agent_title, options = {})
+
+        raise "user_agent_title must be set, please follow the reddit API rules" if user_agent_title == nil
+
+        @name = username
+        @connection = Reddit::Internal::Connection.new(username, password, client_id, secret, user_agent_title, options)
+        @connection.sign_in()
+        @token = @connection.token
+      end
+    end
+  end
+end

data/license.txt

@@ -0,0 +1,7 @@
+MIT License: 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/reddit-api.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'reddit/api/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "reddit-api"
+  spec.version       = Reddit::Api::VERSION
+  spec.authors       = ["="]
+  spec.email         = ["="]
+
+  spec.summary       = "A interface to the reddit API. A clean and simple aproach. Get prying!"
+  spec.description   = ""
+  spec.homepage      = "https://github.com/karl-b/reddit-api"
+
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+
+  spec.add_runtime_dependency "rest-client", "~> 1.0"
+  spec.add_runtime_dependency "log4r"
+  spec.add_runtime_dependency "pry"
+end

metadata

@@ -0,0 +1,148 @@
+--- !ruby/object:Gem::Specification
+name: reddit-api
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- '='
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-02-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: log4r
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ''
+email:
+- '='
+executables:
+- reddit-api
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- data.json
+- data/reddit_api.json
+- exe/reddit-api
+- lib/reddit/api.rb
+- lib/reddit/api/version.rb
+- lib/reddit/internal/connection.rb
+- lib/reddit/internal/logger.rb
+- lib/reddit/internal/processor.rb
+- lib/reddit/services.rb
+- lib/reddit/services/user.rb
+- license.txt
+- reddit-api.gemspec
+homepage: https://github.com/karl-b/reddit-api
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: A interface to the reddit API. A clean and simple aproach. Get prying!
+test_files: []