RubyGems - stacked - Versions diffs - 0.5.0 - Mend

stacked 0.5.0

Files changed (56) hide show

data/.document +5 -0
data/.gitignore +6 -0
data/Gemfile +1 -0
data/LICENSE +20 -0
data/README.markdown +37 -0
data/README.rdoc +18 -0
data/Rakefile +51 -0
data/VERSION +1 -0
data/cleaner.rb +29 -0
data/doc/Stacked.html +155 -0
data/doc/Stacked/Answer.html +1394 -0
data/doc/Stacked/Badge.html +480 -0
data/doc/Stacked/Base.html +1124 -0
data/doc/Stacked/Comment.html +1037 -0
data/doc/Stacked/NotImplemented.html +162 -0
data/doc/Stacked/Posttimeline.html +543 -0
data/doc/Stacked/Question.html +1763 -0
data/doc/Stacked/Reputation.html +606 -0
data/doc/Stacked/Tag.html +267 -0
data/doc/Stacked/User.html +2787 -0
data/doc/Stacked/Usertimeline.html +630 -0
data/doc/_index.html +246 -0
data/doc/file.README.html +54 -0
data/doc/index.html +54 -0
data/doc/method_list.html +1203 -0
data/doc/top-level-namespace.html +87 -0
data/genddoc.sh +12 -0
data/lib/stacked.rb +46 -0
data/lib/stacked/answer.rb +43 -0
data/lib/stacked/badge.rb +18 -0
data/lib/stacked/base.rb +159 -0
data/lib/stacked/comment.rb +37 -0
data/lib/stacked/posttimeline.rb +10 -0
data/lib/stacked/question.rb +85 -0
data/lib/stacked/reputation.rb +15 -0
data/lib/stacked/tag.rb +9 -0
data/lib/stacked/user.rb +195 -0
data/lib/stacked/usertimeline.rb +14 -0
data/spec/sorted_by_spec.rb +24 -0
data/spec/spec_helper.rb +16 -0
data/spec/stacked/answer_spec.rb +31 -0
data/spec/stacked/badge_spec.rb +17 -0
data/spec/stacked/base_spec.rb +27 -0
data/spec/stacked/comment_spec.rb +41 -0
data/spec/stacked/question_spec.rb +110 -0
data/spec/stacked/reputation_spec.rb +18 -0
data/spec/stacked/tag_spec.rb +21 -0
data/spec/stacked/user_spec.rb +187 -0
data/spec/stacked/usertimeline_spec.rb +5 -0
data/spec/support/aliases.rb +7 -0
data/spec/support/sorted_by.rb +31 -0
data/spec/support/within.rb +24 -0
data/spec/within_spec.rb +19 -0
data/stacked.gemspec +115 -0
data/stylesheet.css +41 -0
metadata +157 -0

@@ -0,0 +1,87 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+  <head>
+    <meta name="Content-Type" content="text/html; charset=utf-8" />
+<title>Top Level Namespace</title>
+<link rel="stylesheet" href="css/style.css" type="text/css" media="screen" charset="utf-8" />
+<link rel="stylesheet" href="css/common.css" type="text/css" media="screen" charset="utf-8" />
+<script type="text/javascript" charset="utf-8">
+  relpath = '';
+  if (relpath != '') relpath += '/';
+</script>
+<script type="text/javascript" charset="utf-8" src="js/jquery.js"></script>
+<script type="text/javascript" charset="utf-8" src="js/app.js"></script>
+  </head>
+  <body>
+    <script type="text/javascript" charset="utf-8">
+      if (window.top.frames.main) document.body.className = 'frames';
+    </script>
+    <div id="header">
+      <div id="menu">
+    <a href="_index.html">Index</a> &raquo;
+    <span class="title">Top Level Namespace</span>
+  <div class="noframes"><span class="title">(</span><a href="." target="_top">no frames</a><span class="title">)</span></div>
+</div>
+      <div id="search">
+  <a id="class_list_link" href="#">Class List</a>
+  <a id="method_list_link" href="#">Method List</a>
+  <a id ="file_list_link" href="#">File List</a>
+</div>
+      <div class="clear"></div>
+    </div>
+    <iframe id="search_frame"></iframe>
+    <div id="content"><h1>Top Level Namespace
+</h1>
+<dl class="box">
+</dl>
+<div class="clear"></div>
+<h2>Defined Under Namespace</h2>
+<p class="children">
+      <strong class="modules">Modules:</strong> <a href="Stacked.html" title="Stacked (module)">Stacked</a>
+</p>
+</div>
+    <div id="footer">
+  Generated on Sun Apr  4 18:16:35 2010 by
+  <a href="http://yardoc.org" title="Yay! A Ruby Documentation Tool">yard</a>
+  0.5.4 (ruby-1.8.7).
+</div>
+  </body>
+</html>

data/genddoc.sh ADDED

@@ -0,0 +1,12 @@
+#!/bin/bash
+yardoc lib/**/*.rb &&
+rm -rf ../stacked-doc &&
+mkdir -p ../stacked-doc &&
+mv doc/* ../stacked-doc &&
+git checkout gh-pages &&
+rm -rf * &&
+mv ../stacked-doc/* . &&
+git add . &&
+git commit -m "Updated documentation." &&
+git push origin gh-pages &&
+git checkout master

data/lib/stacked.rb ADDED

@@ -0,0 +1,46 @@
+begin
+  require 'rubygems'
+rescue LoadError
+  require 'bundler'
+  Bundler.setup!
+end
+require 'active_support'
+module Stacked
+  # TODO: Use this coupled with autoload_under when AS 3.0 becomes "stable":
+  # extend ActiveSupport::Autoload
+  # Will not then need to implement it ourselves.
+  #
+  # Implement some AS 3.0 code for automatically determining autoload path.
+  # Allows us to do:
+  #
+  # autoload :Base
+  #
+  # Instead of:
+  #
+  # autoload :Base, 'stacked/base'
+  class << self
+    def autoload(klass)
+      super(klass, "stacked/#{klass.to_s.underscore}")
+    end
+  end
+  autoload :Answer
+  autoload :Base
+  autoload :Badge
+  autoload :Comment
+  autoload :Posttimeline
+  autoload :Question
+  autoload :Reputation
+  autoload :Tag
+  autoload :User
+  autoload :Usertimeline
+  class NotImplemented < StandardError
+    def message
+      "The requested action is not available in the API."
+    end
+  end
+end

data/lib/stacked/answer.rb ADDED

@@ -0,0 +1,43 @@
+module Stacked
+  class Answer < Base
+    attr_accessor :accepted,
+                  :answer_id,
+                  :body,
+                  :comments,
+                  :community_owned,
+                  :creation_date,
+                  :down_vote_count,
+                  :last_edit_date,
+                  :owner_display_name,
+                  :owner_user_id,
+                  :question_id,
+                  :score,
+                  :title,
+                  :up_vote_count,
+                  :view_count
+    class << self
+      def all(*args)
+        raise Stacked::NotImplemented
+      end
+    end
+    # A Stacked::User object representing the owner of the answer.
+    def owner
+      @owner ||= User.find(owner_user_id)
+    end
+    # A Stacked::Question object representing the question the answer is in response to.
+    def question
+      @question ||= Question.find(question_id)
+    end
+    alias_method :created_at, :creation_date
+    alias_method :updated_at, :last_edit_date
+    alias_method :id, :answer_id
+    alias_method :up_votes, :up_vote_count
+    alias_method :views, :view_count
+    alias_method :user, :owner
+  end
+end

data/lib/stacked/badge.rb ADDED

@@ -0,0 +1,18 @@
+module Stacked
+  class Badge < Base
+    attr_accessor :award_count,
+                  :badge_id,
+                  :class,
+                  :description,
+                  :name
+    collection :tags
+    alias_method :id, :badge_id
+    class << self
+      alias_method :name, :all
+    end
+  end
+end

data/lib/stacked/base.rb ADDED

@@ -0,0 +1,159 @@
+require 'httparty'
+require 'pathname'
+module Stacked
+  class Base
+    include HTTParty
+    delegate :request, :singular, :parse, :to => "self.class"
+    class << self
+      # Return the stats provided by the API.
+      def stats
+        request(base + "stats")["stats"]
+      end
+      # All the first group (depends on pagesize) of records for current class.
+      def all(options = {})
+        records(path, options)
+      end
+      # A single record belonging to the current class.
+      def find(id, options={})
+        self.new(request(singular(id), options)[resource.singularize])
+      end
+      # All records for a given request path.
+      def records(p = path, options = {})
+        parse(request(p, options)[resource])
+      end
+      # Raw Hash of request.
+      def request(p = path, options = {})
+        get(p, :query => { :key => key }.merge!(options))
+      end
+      # Define collection methods, such as newest.
+      def collection(*names)
+        # Forgive me Matz for I have sinned.
+        for name in names
+          eval <<-EVAL
+            def self.#{name}(options = {})
+              records(path + "#{name}", options)
+            end
+          EVAL
+        end
+      end
+      # Defines association methods for things such as comments on questions.
+      def association(assoc)
+        instance_eval do
+          assoc = assoc.to_s
+          define_method("#{assoc}=") do |records|
+            instance_variable_set("@#{assoc}", records.map { |record| "Stacked::#{assoc.classify}".constantize.new(record) })
+          end
+          define_method(assoc) { instance_variable_get("@#{assoc}") }
+        end
+      end
+      # The path to the singular resource.
+      def singular(id)
+        path + id.to_s
+      end
+      private
+      # The root URL of the API,
+      def base
+        Pathname.new("http://api.stackoverflow.com/0.5/")
+      end
+      # The key to let us in.
+      def key
+        "knockknock"
+      end
+      # Convert the records into actual objects.
+      def parse(records, klass=self)
+        records.map { |record| klass.new(record) }
+      end
+      # The path to this particular part of the API.
+      # Example if the class is Stacked::Question:
+      #
+      # http://api.stackoverflow.com/0.5/questions
+      def path
+        base + resource
+      end
+      # The Stack Overflow friendly version of the class, pluralized.
+      def resource
+        self.to_s.demodulize.downcase.pluralize
+      end
+    end
+    # Convert an answers result into a collection of Stacked::Answer objects.
+    def parse_answers(result)
+      parse_type(result, "answer")
+    end
+    # Convert a badges result into a collection of Stacked::Badge objects.
+    def parse_badges(result)
+      parse_type(result, "badge")
+    end
+    # Convert a comments result into a collection of Stacked::Comment objects.
+    def parse_comments(result)
+      parse_type(result, "comment")
+    end
+    # Convert a post timeline result into a collection of Stacked::Posttimeline objects.
+    def parse_post_timeline(result)
+      parse_type(result, "posttimeline")
+    end
+    # Convert a questions result into a collection of Stacked::Question objects.
+    def parse_questions(result)
+      parse_type(result, "question")
+    end
+    # Convert a reputation result into a collection of Stacked::Reputation objects.
+    def parse_reputations(result)
+      parse_type(result, "reputation")
+    end
+    # Convert a tags result into a collection of Stacked::Tag objects.
+    def parse_tags(result)
+      parse_type(result, "tag")
+    end
+    # Convert a user timeline result into a collection of Stacked::Usertimeline objects.
+    def parse_user_timeline(result)
+      parse_type(result, "usertimeline")
+    end
+    # Converts the specified result into objects of the +type+ class.
+    def parse_type(result, type)
+      parse(result[type.pluralize], "Stacked::#{type.classify}".constantize)
+    end
+    public
+    # Finds a post based on the +post_type+ and +post_id+
+    def post
+      "Stacked::#{post_type.classify}".constantize.find(post_id)
+    end
+    # Creates a new object of the given class based on the attributes passed in.
+    def initialize(attributes)
+      # p self
+      # p attributes.keys.sort.map { |t| t.to_sym }
+      attributes.each do |k, v|
+        self.send("#{k}=", v)
+      end
+    end
+  end
+end

data/lib/stacked/comment.rb ADDED

@@ -0,0 +1,37 @@
+module Stacked
+  class Comment < Base
+    attr_accessor :body,
+                  :comment_id,
+                  :creation_date,
+                  :edit_count,
+                  :owner_display_name,
+                  :owner_user_id,
+                  :post_id,
+                  :post_type,
+                  :reply_to_user_id,
+                  :score
+    class << self
+      def all(*args)
+        raise Stacked::NotImplemented
+      end
+    end
+    # Finds the user this comment was in reply to.
+    # nil if no user.
+    def reply_to
+      Stacked::User.find(reply_to_user_id) if reply_to_user_id
+    end
+    # The owner of this comment.
+    def owner
+      @owner ||= Stacked::User.find(owner_user_id)
+    end
+    alias_method :created_at, :creation_date
+    alias_method :id, :comment_id
+    alias_method :user, :owner
+    alias_method :edits, :edit_count
+  end
+end

data/lib/stacked/posttimeline.rb ADDED

@@ -0,0 +1,10 @@
+module Stacked
+  class Posttimeline < Base
+    attr_accessor :action,
+                  :action_user_id,
+                  :creation_date,
+                  :post_id,
+                  :timeline_type,
+                  :user_id
+  end
+end

data/lib/stacked/question.rb ADDED

@@ -0,0 +1,85 @@
+module Stacked
+  class Question < Base
+    attr_accessor :accepted_answer_id,
+                  :answer_count,
+                  :answers,
+                  :body,
+                  :bounty_closes_date,
+                  :community_owned,
+                  :creation_date,
+                  :down_vote_count,
+                  :favorite_count,
+                  :last_activity_date,
+                  :last_edit_date,
+                  :owner_display_name,
+                  :owner_user_id,
+                  :question_id,
+                  :score,
+                  :tags,
+                  :title,
+                  :up_vote_count,
+                  :view_count
+    # TODO: Combine this into a "has_many"-esque method when I'm not jetlagged.
+    association :comments
+    association :answers
+    collection :active,
+               :featured,
+               :hot,
+               :month,
+               :newest,
+               :unanswered,
+               :votes,
+               :week
+    # The Stacked::Answer representing the accepted answer.
+    # nil if none accepted
+    def accepted_answer
+      Answer.find(accepted_answer_id) if accepted_answer_id
+    end
+    # The Stacked::User representation of the owner.
+    def owner
+      @owner ||= User.find(owner_user_id)
+    end
+    # A timeline of the question.
+    def timeline(options={})
+      parse_post_timeline(request(singular(id) + "timeline", options))
+    end
+    # Helper method for creating Stacked::Tag objects when initializing new Stacked::Question objects.
+    def tags=(tags)
+      @tags = tags.map { |name| Tag.new(:name => name) }
+    end
+    alias_method :created_at, :creation_date
+    alias_method :down_votes, :down_vote_count
+    alias_method :favorites, :favorite_count
+    alias_method :favourites, :favorite_count
+    alias_method :id, :question_id
+    alias_method :updated_at, :last_edit_date
+    alias_method :up_votes, :up_vote_count
+    alias_method :user, :owner
+    alias_method :views, :view_count
+    class << self
+      alias_method :newest_unanswered, :unanswered
+      # All unanswered questions ordered by votes.
+      def unanswered_by_votes(options={})
+        records(path + "unanswered/votes", options)
+      end
+      # All questions tagged with the given tags.
+      # Accepts tags as either +:tags+ or +:tagged+
+      # Must be an Array of tags.
+      def tagged(options={})
+        options[:tagged] ||= []
+        options[:tagged] = (options[:tagged] << options[:tags]).join(", ")
+        records(path + "tagged", options)
+      end
+    end
+  end
+end