stacked 0.5.0

data/lib/stacked/reputation.rb

@@ -0,0 +1,15 @@
+module Stacked
+  class Reputation < Base
+    attr_accessor :negative_rep,
+                  :on_date,
+                  :positive_rep,
+                  :post_id,
+                  :post_type,
+                  :title
+
+    # Return the cumulative score of this reputation.
+    def score
+      positive_rep - negative_rep
+    end
+  end
+end

data/lib/stacked/tag.rb

@@ -0,0 +1,9 @@
+module Stacked
+  class Tag < Base
+    attr_accessor :count,
+                  :name
+
+    collection :popular, :name, :recent
+
+  end
+end

data/lib/stacked/user.rb

@@ -0,0 +1,195 @@
+module Stacked
+  class User < Base
+    attr_accessor :about_me,
+                  :accept_rate,
+                  :age,
+                  :answer_count,
+                  :creation_date,
+                  :display_name,
+                  :down_vote_count,
+                  :email_hash,
+                  :last_access_date,
+                  :location,
+                  :question_count,
+                  :reputation,
+                  :up_vote_count,
+                  :user_id,
+                  :user_type,
+                  :view_count,
+                  :website_url
+
+    collection :newest, :oldest, :name
+
+    class << self
+      alias_method :reputation, :all
+
+      # Returns users matching the given filter.
+      def filter(filter, options={})
+        options.reverse_merge!(:filter => filter)
+        records(path, options)
+      end
+    end
+
+    ###########
+    # Answers #
+    ###########
+    
+    # Paginated answers for this user.
+    def answers(options={})
+      parse_answers(request(singular(id) + "answers", options))
+    end
+    
+    # Paginated answers by views for this user.
+    def answers_by_views(options={})
+      parse_answers(request(singular(id) + "answers/views", options))
+    end
+    
+    # Paginated answers by votes for this user.
+    def answers_by_votes(options={})
+      parse_answers(request(singular(id) + "answers/votes", options))
+    end
+
+    # Newest answers for this user.
+    def newest_answers(options={})
+      parse_answers(request(singular(id) + "answers/newest", options))
+    end
+
+    ############
+    # Comments #
+    ############
+    
+    # Paginated comments for this user.
+    def comments(options={})
+      parse_comments(request(singular(id) + "comments", options))
+    end
+
+    # Find a comment directed at +other_user_id+.
+    # Works only if you specify it the correct range.
+    # This method's a bit funny. http://dev.meta.stackoverflow.com/questions/34747/comments-api-method
+    def directed_at(other_user_id, options={})
+      parse_comments(request(singular(id) + "comments" + other_user_id.to_s, options))
+    end
+    
+    # All comments directed at +other_user_id+ ordered by creation date in descending order.
+    def directed_at_by_date(other_user_id, options={})
+      parse_comments(request(singular(id) + "comments" + other_user_id.to_s + "recent", options))
+    end
+  
+    # All comments directed at +other_user_id+ ordered by votes.
+    def directed_at_by_score(other_user_id, options={})
+      parse_comments(request(singular(id) + "comments" + other_user_id.to_s + "score", options))
+    end
+
+    # Paginated comments for this user ordered by score.
+    def comments_by_score(options={})
+      parse_comments(request(singular(id) + "comments/score", options))
+    end
+
+    alias_method :popular_comments, :comments_by_score
+
+    # Paginated comments for this user ordered by date created.
+    def recent_comments(options={})
+      parse_comments(request(singular(id) + "comments/recent", options))
+    end
+
+    ##############
+    # Favourites #
+    ##############
+
+    # Paginated favorites in the order they were added.
+    def added_favorites(options={})
+      parse_questions(request(singular(id) + "favorites/added", options))
+    end
+
+    # Paginated favorites.
+    def favorites(options={})
+      parse_questions(request(singular(id) + "favorites", options))
+    end
+
+    def newest_favorites(options={})
+      parse_questions(request(singular(id) + "favorites/newest", options))
+    end
+
+    def popular_favorites(options={})
+      parse_questions(request(singular(id) + "favorites/views", options))
+    end
+
+    alias_method :favorites_by_views, :popular_favorites
+    alias_method :favourites_by_views, :popular_favorites
+
+    def recent_favorites(options={})
+      parse_questions(request(singular(id) + "favorites/recent", options))
+    end
+
+    # Silly Americans.
+    alias_method :added_favourites, :added_favorites
+    alias_method :favourites, :favorites
+    alias_method :popular_favourites, :popular_favorites
+    alias_method :recent_favourites, :favorites
+    alias_method :newest_favourites, :newest_favorites
+
+    #############
+    # Questions #
+    #############
+
+    def newest_questions(options={})
+      parse_questions(request(singular(id) + "questions/newest", options))
+    end
+
+    def questions(options={})
+      parse_questions(request(singular(id) + "questions", options))
+    end
+
+    def questions_by_views(options={})
+      parse_questions(request(singular(id) + "questions/views", options))
+    end
+
+    def questions_by_votes(options={})
+      parse_questions(request(singular(id) + "questions/votes", options))
+    end
+
+    alias_method :popular_questions, :questions_by_votes
+
+    def recent_questions(options={})
+      parse_questions(request(singular(id) + "questions/recent", options))
+    end
+
+    ###############
+    # Other stuff #
+    ###############
+
+    def reputations(options={})
+      parse_reputations(request(singular(id) + "reputation", options))
+    end
+
+    def mentioned(options={})
+      parse_comments(request(singular(id) + "mentioned", options))
+    end
+    
+    def badges(options={})
+      parse_badges(request(singular(id) + "badges", options))
+    end
+    
+    def tags(options={})
+      parse_tags(request(singular(id) + "tags", options))
+    end
+
+    alias_method :mentions, :mentioned
+
+    def timeline(options={})
+      parse_user_timeline(request(singular(id) + "timeline", options))
+    end
+
+    alias_method :created_at, :creation_date
+    alias_method :down_votes, :down_vote_count
+    alias_method :gravatar, :email_hash
+    alias_method :id, :user_id
+    alias_method :name, :display_name
+    alias_method :recent_answers, :answers
+    alias_method :type, :user_type
+    alias_method :up_votes, :up_vote_count
+    alias_method :views, :view_count
+
+
+  end
+end

data/lib/stacked/usertimeline.rb

@@ -0,0 +1,14 @@
+module Stacked
+  # I would really *love* to call this UserTimeline but alas, the API fails me.
+  class Usertimeline < Base
+    attr_accessor :action,
+                  :comment_id,
+                  :creation_date,
+                  :description,
+                  :detail,
+                  :post_id,
+                  :timeline_type
+
+    alias_method :created_at, :creation_date
+  end
+end

data/spec/sorted_by_spec.rb

@@ -0,0 +1,24 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Spec::Matchers::Sortedby do
+  before do
+    @questions = []
+    @questions << Stacked::Question.new(:last_edit_date => Time.now.to_i)
+    @questions << Stacked::Question.new(:last_edit_date => (Time.now + 5.days).to_i)
+  end
+
+  subject { @questions }
+
+  it "sorted by" do
+    subject.should be_sorted_by(:last_edit_date)
+  end
+
+  it "sorted by reverse" do
+    subject.reverse.should be_sorted_by(:last_edit_date, :desc)
+  end
+
+  it "fails with an understandable error message" do
+    lambda { subject.reverse.should be_sorted_by(:last_edit_date, :asc) }.should raise_error("Expected result set to be sorted by last_edit_date in ascending order, but was not.")
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'stacked'
+require 'spec'
+require 'spec/autorun'
+require 'fakeweb'
+
+Dir["spec/support/**/*.rb"].each { |f| require f }
+
+# Uncomment only for debugging as we only ever want to test against the real API.
+# At least, until it becomes stable.
+# FakeWeb.allow_net_connect = false
+
+Spec::Runner.configure do |config|
+
+end

data/spec/stacked/answer_spec.rb

@@ -0,0 +1,31 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Stacked::Answer do
+  context "class methods" do
+    it "raises an error if all is called" do
+      lambda { Stacked::Answer.all }.should raise_error(Stacked::NotImplemented, "The requested action is not available in the API.")
+    end
+  end
+
+  context "instance methods" do
+    subject { Stacked::Answer.find(1237127, :body => true) }
+    it "finds the user for an answer" do
+      subject.user.display_name.should eql("Daniel Vandersluis")
+    end
+
+    it "finds the question for an answer" do
+      subject.question.should be_is_a(Stacked::Question)
+    end
+
+    aliases(:views      => :view_count,
+            :up_votes   => :up_vote_count,
+            :answer_id  => :id,
+            :created_at => :creation_date,
+            :updated_at => :last_edit_date)
+
+    it "has a body" do
+      subject.body.should_not be_blank
+    end
+  end
+
+end

data/spec/stacked/badge_spec.rb

@@ -0,0 +1,17 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Stacked::Badge do
+  subject { Stacked::Badge }
+  it "finds all badges" do
+    subject.all.first.should be_is_a(Stacked::Badge)
+  end
+
+  it "finds all badges ordered by name" do
+    subject.name.first.should be_is_a(Stacked::Badge)
+  end
+
+  it "finds all badges based on tags" do
+    subject.tags.first.name.should eql(".net")
+  end
+
+end

data/spec/stacked/base_spec.rb

@@ -0,0 +1,27 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Stacked::Base do
+  context "common methods" do
+    # We cannot use Stacked::Base here obviously because SO does not have Bases!
+    # So we use User instead.
+    subject { Stacked::User }
+
+    it "retrieves a list of a resource" do
+      subject.all.all? { |u| u.is_a?(subject) }.should be_true
+    end
+
+    it "paginates through the resource" do
+      subject.all.first.should_not eql(subject.all(:page => 2).first)
+    end
+
+    it "limits the results" do
+      subject.all(:pagesize => 1).size.should eql(1)
+    end
+    
+    it "stats" do
+      Stacked::Base.stats.keys.sort.should eql(["answers_per_minute", "api_version", "badges_per_minute", "questions_per_minute", "total_answers", "total_badges", "total_comments", "total_questions", "total_unanswered", "total_users", "total_votes"])
+    end
+
+  end
+
+end

data/spec/stacked/comment_spec.rb

@@ -0,0 +1,41 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Stacked::Comment do
+  subject { Stacked::Comment }
+
+  context "class methods" do
+
+    it "raises an error if all is called" do
+      lambda { Stacked::Comment.all }.should raise_error(Stacked::NotImplemented, "The requested action is not available in the API.")
+    end
+
+    it "finds a single comment" do
+      comment = Stacked::Comment.find(2561833)
+      comment.should be_is_a(Stacked::Comment)
+      comment.owner_user_id.should eql(22656)
+    end
+  end
+
+  context "instance methods" do
+    subject { Stacked::Comment.find(2561833) }
+
+    aliases(:comment_id => :id,
+            :created_at => :creation_date,
+            :owner      => :user,
+            :edits      => :edit_count)
+
+    it "finds the related post for this comment" do
+      subject.post.should be_is_a(Stacked::Answer)
+    end
+
+    it "finds who the comment was directed at, or nobody if nobody" do
+      Stacked::Comment.find(2561833).reply_to.should be_is_a(Stacked::User)
+      Stacked::Comment.find(1063043).reply_to.should be_nil
+    end
+
+    it "finds the user who wrote the comment" do
+      subject.owner.should be_is_a(Stacked::User)
+    end
+  end
+
+end

data/spec/stacked/question_spec.rb

@@ -0,0 +1,110 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Stacked::Question do
+  context "class methods" do
+    subject { Stacked::Question }
+    it "gets a list of all questions" do
+      subject.all.all? { |q| q.is_a?(subject) }.should be_true
+    end
+
+    it "gets a list of questions with comments" do
+      pending("Cannot currently get a list of questions with comments")
+      subject.all(:comments => true)
+    end
+
+    it "active" do
+      subject.active(:pagesize => 1).first.last_activity_date.should be_within(1.day)
+    end
+
+    it "newest" do
+      subject.newest(:pagesize => 1).first.creation_date.should be_within(1.day)
+    end
+
+    it "featured" do
+      (subject.featured(:pagesize => 1).first.bounty_closes_date > Time.now.to_i).should be_true
+    end
+
+    it "hot" do
+      # It was 3555 as of 3rd April 2010.
+      (subject.hot(:pagesize => 1).first.view_count > 3555).should be_true
+    end
+
+    it "month" do
+      subject.month(:pagesize => 1).first.creation_date.should be_within(1.month)
+    end
+
+    it "week" do
+      subject.week(:pagesize => 1).first.creation_date.should be_within(1.week)
+    end
+
+    it "votes" do
+      subject.votes(:pagesize => 1).first.up_vote_count.should eql(1190)
+    end
+
+    it "unanswered by votes" do
+      question = subject.unanswered_by_votes(:pagesize => 1).first
+      question.should be_is_a(Stacked::Question)
+      question.answers.should be_blank
+    end
+
+    it "tagged" do
+      question = subject.tagged(:tags => ["ruby", "ruby-on-rails"], :pagesize => 1).first
+      question.tags.map(&:name).should include("ruby")
+      question.tags.map(&:name).should include("ruby-on-rails")
+    end
+  end
+
+  context "instance methods" do
+    subject { Stacked::Question.find(1236996, :comments => true, :body => true) }
+
+    aliases(
+            :created_at => :creation_date,
+            :down_votes => :down_vote_count,
+            :favorites  => :favorite_count,
+            :favourites => :favorite_count,
+            :id         => :question_id,
+            :updated_at => :last_edit_date,
+            :up_votes   => :up_vote_count,
+            :user       => :owner,
+            :views      => :view_count
+            )
+
+
+    it "is the right question" do
+      subject.title.should eql("Calculating the distance between two times")
+    end
+
+    it "has a body" do
+      subject.body.should_not be_blank
+    end
+
+    it "retreives comments" do
+      subject.comments.should_not be_empty
+      subject.comments.first.should be_is_a(Stacked::Comment)
+    end
+
+    it "retreives answers" do
+      subject.answers.should_not be_empty
+      subject.answers.first.should be_is_a(Stacked::Answer)
+    end
+
+    it "retreives tags" do
+      subject.tags.should_not be_empty
+      subject.tags.first.should be_is_a(Stacked::Tag)
+    end
+
+    it "finds the user for a question" do
+      subject.user.should be_is_a(Stacked::User)
+    end
+
+    it "finds the accepted answer" do
+      subject.accepted_answer.should be_is_a(Stacked::Answer)
+    end
+
+    it "shows the timeline of the question" do
+      subject.timeline.first.should be_is_a(Stacked::Posttimeline)
+    end
+
+  end
+
+end