snooby 0.1.0 → 0.1.5

data/LICENSE

@@ -0,0 +1,14 @@
+Copyright (C) 2012 Donnie Akers
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see http://www.gnu.org/licenses.

data/README.md

@@ -4,7 +4,7 @@ Snooby is a wrapper around the reddit API written in Ruby. It aims to make autom
 ## Install
     gem install snooby
 
-## Example
+## Examples
 
 Here's one way you might go about implementing a very simple bot that constantly monitors new comments to scold users of crass language.
 
@@ -13,30 +13,42 @@ 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|
+  probot.r('all').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:
+That covers most of the core features, but here's a look at a few more in closer detail.
+
+```ruby
+reddit = Snooby::Client.new
+
+reddit.user('andrewsmith1986').about['comment_karma'] # => 548027
+reddit.u('violentacrez').trophies.size # => 46
+
+reddit.subreddit('askscience').posts[0].selftext # => We see lots of people...
+reddit.r('pics').message('Ban imgur.', "Wouldn't that be lulzy?")
+
+frontpage = reddit.r # note the lack of parameters
+frontpage.posts[-1].reply('Welcome to the front page.')
+
+# Downvote everything I've ever said. (Note: most of your votes won't count.)
+reddit.u('HazierPhonics').comments(1000).each { |c| c.downvote }
+
+# Similarly, upvote everything on the front page of /r/askscience. (Same disclaimer.)
+reddit.r('askscience').posts.each { |p| p.upvote }
+```
 
-* 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
+The code is thoroughly documented and is the best place to start with questions.
 
 ## TODO
 
-* Pagination
-* Flesh out errors
+* Moderation
 * Much more thorough configuration file
-* Granular caching
+* Granular caching
+* Elegant solution to the "more comments" problem

data/lib/snooby.rb

@@ -2,79 +2,123 @@
 
 module Snooby
   # 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.
+  # during repeated calls; reddit's two-second rule pretty much nullifies this,
+  # but it's still a great library and persistent connections are a Good Thing.
   Conn = Net::HTTP::Persistent.new('snooby')
 
   # 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',
+    :compose            => 'api/compose',
+    :delete             => 'api/del',
+    :disliked           => 'user/%s/disliked.json',
+    :friend             => 'api/friend',
+    :hidden             => 'user/%s/hidden.json',
+    :liked              => 'user/%s/liked.json',
     :login              => 'api/login/%s',
     :me                 => 'api/me.json',
+    :post_comments      => 'comments/%s.json',
+    :reddit             => '.json',
+    :saved              => 'saved.json',
     :subreddit_about    => 'r/%s/about.json',
     :subreddit_comments => 'r/%s/comments.json',
     :subreddit_posts    => 'r/%s.json',
+    :subscribe          => 'api/subscribe',
+    :unfriend           => 'api/unfriend',
     :user               => 'user/%s',
     :user_about         => 'user/%s/about.json',
     :user_comments      => 'user/%s/comments.json',
     :user_posts         => 'user/%s/submitted.json',
+    :vote               => 'api/vote'
   }
-  Paths = paths.merge(paths) { |k, v| 'http://www.reddit.com/' + v }
+  Paths = paths.merge(paths) { |k, v| "http://www.reddit.com/#{v}" }
 
   # 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.
+  # might as well grab all available data (except body_html and selftext_html).
   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]
+    :comment => %w[author author_flair_css_class author_flair_text body 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 subreddit subreddit_id thumbnail title ups url]
   }
 
+  # Wraps the connection created above for both POST and GET requests to ensure
+  # that the two-second rule is adhered to. The uri parameter is turned into an
+  # actual URI once here instead of all over the place. The client's modhash is
+  # always required for POST requests, so it is passed along by default.
+  def self.request(uri, data = nil)
+    uri = URI(uri)
+    if data
+      data.merge!(:uh => Snooby.active.uh) if Snooby.active
+      post = Net::HTTP::Post.new(uri.path)
+      post.set_form_data(data)
+    end
+    Snooby.wait if @last_request && Time.now - @last_request < 2
+    @last_request = Time.now
+    Conn.request(uri, post).body
+  end
+
   # 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)
+  # Having to explicitly pass the path isn't very DRY, but deriving it from the
+  # object (say, Snooby::Comment) doesn't expose which kind of comment it is.
+  def self.build(object, path, which, count)
     # 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)
+    # Set limit to the maximum of 100 if we're grabbing more than that, give
+    # after a truthy value since we stop when it's no longer so, and initialize
+    # an empty result set that the generated structs will be pushed into.
+    limit, after, results = [count, 100].min, '', []
 
-    # 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]))
+    # Fetch data until we've met the count or reached the end of the results.
+    while results.size < count && after
+      uri = Paths[path] % which + "?limit=#{limit}&after=#{after}"
+      json = JSON.parse(Snooby.request(uri), :max_nesting => 100)
+      json = json[1] if path == :post_comments # skip over the post's data
+      json['data']['children'].each do |child|
+        # Converts each child's JSON data into the relevant struct based on the
+        # kind of object being built. The symbols of a struct definition are
+        # ordered, but Python dictionaries are not, so #values is insufficient.
+        # Preliminary testing showed that appending one at a time is slightly
+        # faster than concatenating the entire page of results and then taking
+        # a slice at the end. This also allows for premature stopping if the
+        # count is reached before all results have been processed.
+        results << object.new(*child['data'].values_at(*Fields[kind]))
+        return results if results.size == count
+      end
+      after = json['data']['after']
     end
+    results
   end
 
   class << self
-    attr_accessor :config, :auth
+    attr_accessor :config, :active
   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' => {}}
 
+  # Called whenever respecting the API is required.
+  def self.wait
+    sleep 2
+  end
+
   # 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.
+  # returns a non-empty "errors" array, typically in cases of rate limiting and
+  # missing or inaccurate 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|
+%w[client actions user subreddit post comment].each do |d|
   require "snooby/#{d}"
 end

data/lib/snooby/actions.rb

@@ -1,69 +1,78 @@
 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.
+  module About
+    # Returns a hash containing the calling object's about.json data.
     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']
+      JSON.parse(Snooby.request(uri))['data']
     end
+  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
+  module Posts
+    # Returns an array of structs containing the calling object's posts.
+    def posts(count = 25)
+      path = @name ? :"#{@kind}_posts" : :reddit
+      Snooby.build(Post, path, @name, count)
+    end
+  end
 
-      Snooby.build(Post, :"#{@kind}_posts", @name)
+  module Comments
+    # Returns an array of structs containing the calling object's comments.
+    # TODO: return more than just top-level comments for posts.
+    def comments(count = 25)
+      # @name suffices for users and subreddits, but a post's name is obtained
+      # from its struct; the "t3_" must be removed before making the API call.
+      @name ||= self.name[3..-1]
+      Snooby.build(Comment, :"#{@kind}_comments", @name, count)
     end
+  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
+  module Reply
+    # Posts a reply to the calling object, which is either a post or a comment.
+    def reply(text)
+      raise RedditError, 'You are not logged in.' unless Snooby.active
+
+      data = {:parent => self.name, :text => text, :api_type => 'json'}
+      resp = Snooby.request(Paths[:comment], data)
+      json = JSON.parse(resp)['json']
 
-      Snooby.build(Comment, :"#{@kind}_comments", @name)
+      raise RedditError, jj(json) unless json['errors'].empty?
     end
+  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'
+  module Delete
+    # Deletes the calling object, which is either a post or a comment, as long
+    # as it belongs to the currently authorized user.
+    def delete
+      raise RedditError, 'You are not logged in.' unless Snooby.active
+      unless self.author == Snooby.active.username
+        #raise CommonDecencyError
+        raise RedditError, "You can't delete somebody else's content."
+      end
 
-      # 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?>([^<]*)</)
+      Snooby.request(Paths[:delete], :id => self.name)
     end
+  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
+  module Compose
+    # Sends a message to the calling object, which is either a subreddit or a
+    # user; in the case of the former, this behaves like moderator mail.
+    def compose(subject, text)
+      raise RedditError, 'You are not logged in.' unless Snooby.active
 
-      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']
+      to = (@kind == 'user' ? '' : '#') + @name
+      data = {:to => to, :subject => subject, :text => text}
+      Snooby.request(Paths[:compose], data)
+    end
+    alias :message :compose
+  end
 
-      # 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
+  module Voting
+    def vote(dir)
+      Snooby.request(Paths[:vote], :id => self.name, :dir => dir)
     end
+
+    def upvote; vote 1; end
+    def rescind; vote 0; end
+    def downvote; vote -1; end
   end
 end

data/lib/snooby/client.rb

@@ -1,7 +1,12 @@
 module Snooby
   # Interface through which Snooby does all of its interacting with the API.
   class Client
-    def initialize(user_agent = 'Snooby')
+    # Exposes username to raise a proper error in case of an attempt to delete
+    # another user's content, modhash (uh) for sending along in the headers on
+    # API calls that change state, and id for (un)friending.
+    attr_reader :username, :uh, :id
+
+    def initialize(user_agent = "Snooby, #{rand}")
       # 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.
@@ -12,54 +17,90 @@ module Snooby
     # 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)
+      @username = user
+
       if Snooby.config['auth'][user] && !force_update
         # Authorization data exists, skip login and potential rate-limiting.
-        @modhash, @cookie = Snooby.config['auth'][user]
+        @uh, @cookie, @id = 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']
+        data = {:user => user, :passwd => passwd, :api_type => 'json'}
+        resp = Snooby.request(Paths[:login] % user, data)
+        json = JSON.parse(resp)['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 }
+        raise RedditError, jj(json) unless json['errors'].empty?
+
+        # Parse authorization data.
+        @uh, @cookie = json['data'].values
       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
+      # 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}"
+      Conn.override_headers['Cookie'] = "reddit_session=#{@cookie}"
 
-      # Allows Snooby's classes to access the currently authorized client.
-      Snooby.auth = @modhash
-    end
+      # A second call is made, if required, to grab the client's id, which is
+      # necessary for (un)friending.
+      @id ||= "t2_#{me['id']}"
 
-    # Returns a hash containing the values supplied by me.json.
-    def me
-      uri = URI(Paths[:me])
-      JSON.parse(Conn.request(uri).body)['data']
+      # Updates the config file to faciliate one-time authorization. This works
+      # because the authorization data is immortal unless the password has been
+      # changed; enable the force_update parameter if such is the case.
+      Snooby.config['auth'][user] = [@uh, @cookie, @id]
+      File.open('.snooby', 'w') { |f| f << Snooby.config.to_json }
+
+      # Allows Snooby's classes to access the currently authorized client.
+      Snooby.active = self
     end
 
-    # Returns a User object from which posts, comments, etc. can be accessed.
+    # Returns a User object through which all relevant data is accessed.
     def user(name)
       User.new(name)
     end
+    alias :u :user
 
-    # As above, so below.
-    def subreddit(name)
+    # Returns a Subreddit object through which all relevant data is accessed.
+    def subreddit(name = nil)
       Subreddit.new(name)
     end
-
-    alias :u :user
     alias :r :subreddit
+
+    # Returns a hash containing the values given by me.json, used internally to
+    # obtain the client's id, but also the most efficient way to check whether
+    # or not the client has mail.
+    def me
+      JSON.parse(Snooby.request(Paths[:me]))['data']
+    end
+
+    # Returns an array of structs containing the current client's saved posts.
+    def saved(count = 25)
+      Snooby.build(Post, :saved, nil, count)
+    end
+
+    # Convenience methods.
+
+    def friend(name)
+      User.new(name).friend
+    end
+
+    def unfriend(name)
+      User.new(name).unfriend
+    end
+
+    def subscribe(name)
+      Subreddit.new(name).subscribe
+    end
+    alias :sub :subscribe
+
+    def unsubscribe(name)
+      Subreddit.new(name).unsubscribe
+    end
+    alias :unsub :unsubscribe
+
+    def compose(to, subject, text)
+      data = {:to => to, :subject => subject, :text => text}
+      Snooby.request(Paths[:compose], data)
+    end
+    alias :message :compose
   end
 end

data/lib/snooby/comment.rb

@@ -0,0 +1,10 @@
+module Snooby
+  class Comment < Struct.new(*Fields[:comment].map(&:to_sym))
+    include Reply, Delete, Voting
+
+    def initialize(*)
+      super
+      @kind = 'comment'
+    end
+  end
+end

data/lib/snooby/post.rb

@@ -0,0 +1,10 @@
+module Snooby
+  class Post < Struct.new(*Fields[:post].map(&:to_sym))
+    include Comments, Reply, Delete, Voting
+
+    def initialize(*)
+      super
+      @kind = 'post'
+    end
+  end
+end

data/lib/snooby/subreddit.rb

@@ -0,0 +1,26 @@
+module Snooby
+  class Subreddit
+    include About, Posts, Comments, Compose
+
+    def initialize(name)
+      @name = name
+      @kind = 'subreddit'
+    end
+
+    # Alas, (un)subscribing by name alone doesn't work, so a separate call must
+    # be made to obtain the subreddit's id, thus the wait. Maybe cache this?
+    def subscribe
+      sr = about['name']
+      Snooby.wait
+      Snooby.request(Paths[:subscribe], :action => 'sub', :sr => sr)
+    end
+    alias :sub :subscribe
+
+    def unsubscribe
+      sr = about['name']
+      Snooby.wait
+      Snooby.request(Paths[:subscribe], :action => 'unsub', :sr => sr)
+    end
+    alias :unsub :unsubscribe
+  end
+end

data/lib/snooby/user.rb

@@ -0,0 +1,46 @@
+module Snooby
+  class User
+    include About, Posts, Comments, Compose
+
+    def initialize(name)
+      @name = name
+      @kind = 'user'
+    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
+      # Only interested in trophies; request the minimum amount of content.
+      html = Snooby.request(URI(Paths[:user] % @name) + '?limit=1')
+      # Entry-level black magic.
+      html.scan(/"trophy-name">(.+?)<.+?"\s?>([^<]*)</)
+    end
+
+    def liked(count = 25)
+      Snooby.build(Post, :liked, @name, count)
+    end
+
+    def disliked(count = 25)
+      Snooby.build(Post, :disliked, @name, count)
+    end
+
+    def hidden(count = 25)
+      Snooby.build(Post, :hidden, @name, count)
+    end
+
+    def friend
+      raise RedditError, 'You are not logged in.' unless Snooby.active
+
+      data = {:name => @name, :type => 'friend', :container => Snooby.active.id}
+      Snooby.request(Paths[:friend], data)
+    end
+
+    def unfriend
+      raise RedditError, 'You are not logged in.' unless Snooby.active
+
+      data = {:name => @name, :type => 'friend', :container => Snooby.active.id}
+      Snooby.request(Paths[:unfriend], data)
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: snooby
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-15 00:00:00.000000000 Z
+date: 2012-02-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
-  requirement: &79734590 !ruby/object:Gem::Requirement
+  requirement: &72574440 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *79734590
+  version_requirements: *72574440
 - !ruby/object:Gem::Dependency
   name: net-http-persistent
-  requirement: &79734280 !ruby/object:Gem::Requirement
+  requirement: &72574180 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,7 +32,7 @@ dependencies:
         version: '2.5'
   type: :runtime
   prerelease: false
-  version_requirements: *79734280
+  version_requirements: *72574180
 description: 
 email:
 - andkerosine@gmail.com
@@ -41,12 +41,16 @@ extensions: []
 extra_rdoc_files: []
 files:
 - Gemfile
+- LICENSE
 - README.md
 - Rakefile
 - lib/snooby.rb
 - lib/snooby/actions.rb
 - lib/snooby/client.rb
-- lib/snooby/objects.rb
+- lib/snooby/comment.rb
+- lib/snooby/post.rb
+- lib/snooby/subreddit.rb
+- lib/snooby/user.rb
 homepage: https://github.com/andkerosine/snooby
 licenses: []
 post_install_message: 

data/lib/snooby/objects.rb

@@ -1,37 +0,0 @@
-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