snooby 0.0.1 → 0.1.0

data/Gemfile

@@ -1,4 +1,2 @@
 source "http://rubygems.org"
-
-# Specify your gem's dependencies in snooby.gemspec
-gemspec
+gemspec

data/README.md

@@ -0,0 +1,42 @@
+# What is Snooby?
+Snooby is a wrapper around the reddit API written in Ruby. It aims to make automating any part of the reddit experience as simple and clear-cut as possible, while still providing ample functionality.
+
+## Install
+    gem install snooby
+
+## Example
+
+Here's one way you might go about implementing a very simple bot that constantly monitors new comments to scold users of crass language.
+
+```ruby
+require 'snooby'
+
+probot = Snooby::Client.new('ProfanityBot, v1.0')
+probot.authorize!('ProfanityBot', 'hunter2')
+while true
+  new_comments = probot.r('all').comments
+  sleep 2 # Respecting the API is currently manual, will be fixed in future.
+  new_comments.each do |com|
+    if com.body =~ /(vile|rotten|words)/
+      com.reply("#{$&.capitalize} is a terrible word, #{com.author}!")
+      sleep 2
+    end
+  end
+  sleep 2
+end
+```
+## Features
+
+Snooby is in the early stages of active development. Most of the code is structure, but there is *some* functionality in place. At the moment, Snooby can:
+
+* grab the first page of comments/posts for a user/subreddit
+* grab about data for users and subreddits
+* grab trophy data
+* reply to comments and posts
+
+## TODO
+
+* Pagination
+* Flesh out errors
+* Much more thorough configuration file
+* Granular caching

data/Rakefile

@@ -1 +1 @@
-require "bundler/gem_tasks"
+require "bundler/gem_tasks"

data/lib/snooby.rb

@@ -1,14 +1,80 @@
-$: << File.expand_path('../lib', $0)
-%w[net/http cgi json].each { |d| require d }
-require 'snooby/user'
+%w[net/http/persistent json].each { |d| require d }
 
 module Snooby
-	# connection to be shared by all instances
-	Reddit = Net::HTTP.new('www.reddit.com')
+  # Opens a persistent connection that provides a significant speed improvement
+  # during repeated calls; reddit's rate limit nullifies this for the most part,
+  # but it's still a nice library and persistent connections are a Good Thing.
+  Conn = Net::HTTP::Persistent.new('snooby')
 
-	# load previously stored user data if it exists
-	class << self; attr_accessor :config; end
-	Snooby.config = JSON.parse(File.read('.snooby')) rescue {}
+  # Provides a mapping of things and actions to their respective URL fragments.
+  # A path is eventually used as a complete URI, thus the merge.
+  paths = {
+    :comment            => 'api/comment',
+    :login              => 'api/login/%s',
+    :me                 => 'api/me.json',
+    :subreddit_about    => 'r/%s/about.json',
+    :subreddit_comments => 'r/%s/comments.json',
+    :subreddit_posts    => 'r/%s.json',
+    :user               => 'user/%s',
+    :user_about         => 'user/%s/about.json',
+    :user_comments      => 'user/%s/comments.json',
+    :user_posts         => 'user/%s/submitted.json',
+  }
+  Paths = paths.merge(paths) { |k, v| 'http://www.reddit.com/' + v }
 
-	class RedditError < StandardError; end
+  # Provides a mapping of things to a list of all the attributes present in the
+  # relevant JSON object. A lot of these probably won't get used too often, but
+  # might as well expose all available data.
+  Fields = {
+    :comment => %w[author author_flair_css_class author_flair_text body body_html created created_utc downs id likes link_id link_title name parent_id replies subreddit subreddit_id ups],
+    :post    => %w[author author_flair_css_class author_flair_text clicked created created_utc domain downs hidden id is_self likes media media_embed name num_comments over_18 permalink saved score selftext selftext_html subreddit subreddit_id thumbnail title ups url]
+  }
+
+  # The crux of Snooby. Generates an array of structs from the Paths and Fields
+  # hashes defined above. In addition to just being a very neat container, this
+  # allows accessing the returned JSON values using thing.attribute, as opposed
+  # to thing['data']['attribute']. Only used for listings of posts and comments
+  # at the moment, but I imagine it'll be used for moderation down the road.
+  def self.build(object, path, which)
+    # A bit of string manipulation to determine which fields to populate the
+    # generated struct with. There might be a less fragile way to go about it,
+    # but it shouldn't be a problem as long as naming remains consistent.
+    kind = object.to_s.split('::')[1].downcase.to_sym
+
+    # Having to explicitly pass the path symbol isn't exactly DRY, but deriving
+    # it from the object parameter (say, Snooby::Comment) doesn't expose which
+    # kind of comment it is, either User or Post.
+    uri = URI(Paths[path] % which)
+
+    # This'll likely have to be tweaked to handle other types of listings, but
+    # it's sufficient for comments and posts.
+    JSON.parse(Conn.request(uri).body)['data']['children'].map do |child|
+      # Maps each of the listing's children to the relevant struct based on the
+      # object type passed in. The symbols in a struct definition are ordered,
+      # but Python dictionaries are not, so #values isn't sufficient.
+      object.new(*child['data'].values_at(*Fields[kind]))
+    end
+  end
+
+  class << self
+    attr_accessor :config, :auth
+  end
+
+  # Used for permanent storage of preferences and authorization data.
+  # Each client should have its own directory to prevent pollution.
+  @config = JSON.parse(File.read('.snooby')) rescue {'auth' => {}}
+
+  # Raised with a pretty print of the relevant JSON object whenever an API call
+  # returns a non-empty "errors" field. Where "pretty" is inapplicable, such as
+  # when the returned JSON object is a series of jQuery calls, a manual message
+  # is displayed instead, typically to inform the user either that they've been
+  # rate-limited or that they lack the necessary authorization.
+  class RedditError < StandardError; end
+end
+
+# Snooby's parts are required down here, after its initial declaration, because
+# Post and Comment are structs whose definitions are taken from the Fields hash
+# above, and related bits might as well be kept together.
+%w[client actions objects].each do |d|
+  require "snooby/#{d}"
 end

data/lib/snooby/actions.rb

@@ -0,0 +1,69 @@
+module Snooby
+  # Mixin to provide functionality to all of the objects in one fell swoop,
+  # both relevant and irrelevant. Errors are thrown where nonsensical methods
+  # are called, but hopefully the intent is to use Snooby sensibly. I realize
+  # this is probably bad design, but it's just so damned clean.
+  module Actions
+    # Returns a hash containing the values supplied by about.json, so long as
+    # the calling object is a User or Subreddit.
+    def about
+      if !['user', 'subreddit'].include?(@kind)
+        raise RedditError, 'Only users and subreddits have about pages.'
+      end
+
+      uri = URI(Paths[:"#{@kind}_about"] % @name)
+      JSON.parse(Conn.request(uri).body)['data']
+    end
+
+    # Returns an array of structs containing the object's posts.
+    def posts
+      if !['user', 'subreddit'].include?(@kind)
+        raise RedditError, 'Only users and subreddits have posts.'
+      end
+
+      Snooby.build(Post, :"#{@kind}_posts", @name)
+    end
+
+    # Returns an array of structs containing the object's comments.
+    def comments
+      if !['user', 'subreddit'].include?(@kind)
+        raise RedditError, 'Only users and subreddits have comments.'
+      end
+
+      Snooby.build(Comment, :"#{@kind}_comments", @name)
+    end
+
+    # Returns an array of 2-tuples containing the user's trophy information in
+    # the form of [name, description], the latter containing the empty string
+    # if inapplicable.
+    def trophies
+      raise RedditError, 'Only users have trophies.' if @kind != 'user'
+
+      # Only interested in trophies; request the minimum amount of content.
+      html = Conn.request(URI(Paths[:user] % @name) + '?limit=1').body
+      # Entry-level black magic.
+      html.scan(/"trophy-name">(.+?)<.+?"\s?>([^<]*)</)
+    end
+
+    # Posts a reply to the caller as the currently authorized user, so long as
+    # that caller is a Post or Comment.
+    def reply(text)
+      raise RedditError, 'You must be authorized to comment.' if !Snooby.auth
+
+      if !['post', 'comment'].include?(@kind)
+        raise RedditError, "Replying to a #{@kind} doesn't make much sense."
+      end
+
+      uri = URI(Paths[:comment])
+      post = Net::HTTP::Post.new(uri.path)
+      data = {:parent => self.name, :text => text, :uh => Snooby.auth}
+      post.set_form_data(data)
+      json = JSON.parse(Conn.request(uri, post).body)['jquery']
+
+      # Bad magic numbers, I know, but getting rate-limited during a reply
+      # returns a bunch of serialized jQuery rather than a straightforward
+      # and meaningful message. Fleshing out errors is on the to-do list.
+      raise RedditError, json[14][3] if json.size == 17
+    end
+  end
+end

data/lib/snooby/client.rb

@@ -0,0 +1,65 @@
+module Snooby
+  # Interface through which Snooby does all of its interacting with the API.
+  class Client
+    def initialize(user_agent = 'Snooby')
+      # Net::HTTP's default User-Agent, "Ruby", is banned on reddit due to its
+      # frequent improper use; cheers to Eric Hodel (drbrain) for implementing
+      # this workaround for net-http-persistent.
+      Conn.override_headers['User-Agent'] = user_agent
+    end
+
+    # Causes the client to be recognized as the given user during API calls.
+    # GET operations do not need to be authorized, so if your intent is simply
+    # to gather data, feel free to disregard this method entirely.
+    def authorize!(user, passwd, force_update = false)
+      if Snooby.config['auth'][user] && !force_update
+        # Authorization data exists, skip login and potential rate-limiting.
+        @modhash, @cookie = Snooby.config['auth'][user]
+      else
+        uri = URI(Paths[:login] % user)
+        post = Net::HTTP::Post.new(uri.path)
+        data = {:user => user, :passwd => CGI.escape(passwd), :api_type => 'json'}
+        post.set_form_data(data)
+        json = JSON.parse(Conn.request(uri, post).body)['json']
+
+        # Will fire for incorrect login credentials and when rate-limited.
+        raise RedditError, jj(json) if !json['errors'].empty?
+
+        # Parse authorization data and store it both in the current config, as
+        # well as in the configuration file for future use. This works because
+        # authorization data is immortal unless the password has changed. The
+        # force_update parameter should be enabled if such is the case.
+        @modhash, @cookie = json['data'].values
+        Snooby.config['auth'][user] = [@modhash, @cookie]
+        File.open('.snooby', 'w') { |f| f << Snooby.config.to_json }
+      end
+
+      # Sets the reddit_session cookie required for API calls to be recognized
+      # as coming from the intended user; uses override_headers to allow for
+      # switching the current user mid-execution, if so desired.
+      Conn.headers['Cookie'] = "reddit_session=#{@cookie}"
+
+      # Allows Snooby's classes to access the currently authorized client.
+      Snooby.auth = @modhash
+    end
+
+    # Returns a hash containing the values supplied by me.json.
+    def me
+      uri = URI(Paths[:me])
+      JSON.parse(Conn.request(uri).body)['data']
+    end
+
+    # Returns a User object from which posts, comments, etc. can be accessed.
+    def user(name)
+      User.new(name)
+    end
+
+    # As above, so below.
+    def subreddit(name)
+      Subreddit.new(name)
+    end
+
+    alias :u :user
+    alias :r :subreddit
+  end
+end

data/lib/snooby/objects.rb

@@ -0,0 +1,37 @@
+module Snooby
+  class User
+    include Actions
+
+    def initialize(name)
+      @name = name
+      @kind = 'user'
+    end
+  end
+
+  class Subreddit
+    include Actions
+
+    def initialize(name)
+      @name = name
+      @kind = 'subreddit'
+    end
+  end
+
+  class Post < Struct.new(*Fields[:post].map(&:to_sym))
+    include Actions
+
+    def initialize(*)
+      super
+      @kind = 'post'
+    end
+  end
+
+  class Comment < Struct.new(*Fields[:comment].map(&:to_sym))
+    include Actions
+
+    def initialize(*)
+      super
+      @kind = 'comment'
+    end
+  end
+end

metadata

@@ -1,29 +1,52 @@
 --- !ruby/object:Gem::Specification
 name: snooby
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
-- andkerosine
+- Donnie Akers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-06 00:00:00.000000000 Z
-dependencies: []
-description: Snooby wraps the reddit API in convenient Ruby.
+date: 2012-02-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: &79734590 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *79734590
+- !ruby/object:Gem::Dependency
+  name: net-http-persistent
+  requirement: &79734280 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '2.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: *79734280
+description: 
 email:
 - andkerosine@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
 - Gemfile
+- README.md
 - Rakefile
 - lib/snooby.rb
-- lib/snooby/version.rb
-- snooby.gemspec
+- lib/snooby/actions.rb
+- lib/snooby/client.rb
+- lib/snooby/objects.rb
 homepage: https://github.com/andkerosine/snooby
 licenses: []
 post_install_message: 
@@ -43,9 +66,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: snooby
+rubyforge_project: 
 rubygems_version: 1.8.15
 signing_key: 
 specification_version: 3
-summary: Ruby wrapper for the reddit API.
+summary: Snooby wraps the reddit API in happy, convenient Ruby.
 test_files: []

data/.gitignore

@@ -1,4 +0,0 @@
-*.gem
-.bundle
-Gemfile.lock
-pkg/*

data/lib/snooby/version.rb

@@ -1,3 +0,0 @@
-module Snooby
-  VERSION = "0.0.1"
-end

data/snooby.gemspec

@@ -1,20 +0,0 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require 'snooby/version'
-
-Gem::Specification.new do |s|
-  s.name        = 'snooby'
-  s.version     = Snooby::VERSION
-  s.authors     = ['andkerosine']
-  s.email       = ['andkerosine@gmail.com']
-  s.homepage    = 'https://github.com/andkerosine/snooby'
-  s.summary     = 'Ruby wrapper for the reddit API.'
-  s.description = 'Snooby wraps the reddit API in convenient Ruby.'
-
-  s.rubyforge_project = 'snooby'
-
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
-end