stacked 0.5.0 → 1.0.0.beta1

data/lib/stacked/client.rb

@@ -0,0 +1,31 @@
+module Stacked
+  # Stacked::Client class.
+  class Client
+    
+    class << self
+      # Default options used to build the request URL. Must override +api_key+
+      DEFAULT_OPTIONS = {
+        :site => 'stackoverflow.com',
+        :version => '1.0',
+        :api_key => 'key'
+      }
+      
+      attr_accessor :site
+      attr_accessor :version
+      attr_accessor :api_key
+      attr_reader   :base_url
+    
+      def configure
+        yield self
+      
+        @site     ||= DEFAULT_OPTIONS[:site]
+        @version  ||= DEFAULT_OPTIONS[:version]
+        @api_key  ||= DEFAULT_OPTIONS[:api_key]
+        @base_url ||= "http://api.#{@site}/#{@version}/"
+      
+        true
+      end
+    end
+    
+  end
+end

data/lib/stacked/comment.rb

@@ -1,37 +1,32 @@
 module Stacked
+  # Stacked::Comment class.
   class Comment < Base
     attr_accessor :body,
                   :comment_id,
                   :creation_date,
                   :edit_count,
-                  :owner_display_name,
-                  :owner_user_id,
+                  :owner,
                   :post_id,
                   :post_type,
-                  :reply_to_user_id,
+                  :reply_to_user,
                   :score
+                  
+    alias_method :reply_to_d, :creation_date
 
     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
+    
+    # Helper method for creating Stacked::User object when initializing new Stacked::Comment objects.
+    def owner=(attributes)
+      @owner = User.new(attributes)
     end
-
-    # The owner of this comment.
-    def owner
-      @owner ||= Stacked::User.find(owner_user_id)
+    
+    # Helper method for creating Stacked::User object when initializing new Stacked::Comment objects.
+    def reply_to_user=(attributes)
+      @reply_to_user = User.new(attributes)
     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/parser.rb

@@ -0,0 +1,47 @@
+module Stacked
+  module Parser
+  # 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, "post_timeline")
+    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_rep_changes(result)
+      parse_type(result, "rep_change")
+    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, "user_timeline")
+    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
+  end
+end

data/lib/stacked/post_timeline.rb

@@ -0,0 +1,17 @@
+module Stacked
+  # Stacked::PostTimeline class.
+  class PostTimeline < Base
+    attr_accessor :action,
+                  :comment_id,
+                  :creation_date,
+                  :owner,
+                  :post_comments_url,
+                  :post_id,
+                  :post_revision_url,
+                  :post_url,
+                  :question_id,
+                  :revision_guid,
+                  :timeline_type,
+                  :user
+  end
+end

data/lib/stacked/question.rb

@@ -1,85 +1,86 @@
 module Stacked
+  # Stacked::Question class.
   class Question < Base
     attr_accessor :accepted_answer_id,
                   :answer_count,
                   :answers,
                   :body,
+                  :bounty_amount,
                   :bounty_closes_date,
+                  :comments,
                   :community_owned,
-                  :creation_date, 
+                  :closed_date,
+                  :closed_reason,
+                  :creation_date,
                   :down_vote_count,
                   :favorite_count,
                   :last_activity_date,
                   :last_edit_date,
-                  :owner_display_name,
-                  :owner_user_id,
+                  :locked_date,
+                  :migrated,
+                  :owner,
+                  :protected_date,
                   :question_id,
+                  :question_answers_url,
+                  :question_comments_url,
+                  :question_timeline_url,
                   :score,
                   :tags,
                   :title,
                   :up_vote_count,
                   :view_count
+    
+    class << self
+      # All questions matching the search.
+      def search(options={})
+        parse(request(base + "search", options)[resource])
+      end
 
-    # 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
+      # All unanswered questions.
+      def unanswered(options={})
+        records(path + "/unanswered", options)
+      end
+    end
+    
+    # Answers for the question.
+    def answers(options={})
+      @answers = self.class.parse_answers(request(singular(question_id) + "/answers", options))
+    end
+    
+    # Comments for the question.
+    def comments(options={})
+      @comments ||= self.class.parse_comments(request(singular(question_id) + "/comments", options))
+    end
 
+    # A timeline of the question.
+    def timeline(options={})
+      self.class.parse_post_timeline(request(singular(question_id) + "/timeline", options))
+    end
+    
     # 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)
+    
+    # Helper method for creating Stacked::Answer object when initializing new Stacked::Question objects.
+    def answers=(ans)
+      @answers = ans.map { |a| Answer.new(a) }
     end
-
-    # A timeline of the question.
-    def timeline(options={})
-      parse_post_timeline(request(singular(id) + "timeline", options))
+    
+    # Helper method for creating Stacked::Comment object when initializing new Stacked::Question objects.
+    def comments=(coms)
+      @comments = coms.map { |c| Comment.new(c) }
+    end
+    
+    # Helper method for creating Stacked::User object when initializing new Stacked::Question objects.
+    def owner=(attributes)
+      @owner = User.new(attributes)
     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

data/lib/stacked/{reputation.rb → rep_change.rb}

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

data/lib/stacked/tag.rb

@@ -1,9 +1,17 @@
 module Stacked
+  # Stacked::Tag class.
   class Tag < Base
     attr_accessor :count,
-                  :name
+                  :fulfills_required,
+                  :name,
+                  :restricted_to,
+                  :user_id
 
-    collection :popular, :name, :recent
+    class << self
+      def find(*args)
+        raise Stacked::NotImplemented
+      end
+    end
 
   end
 end

data/lib/stacked/user.rb

@@ -1,195 +1,63 @@
 module Stacked
+  # Stacked::User class.
   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)
+      # All moderators.
+      def moderators(options={})
+        records(path + "/moderators", options)
       end
     end
 
-    ###########
-    # Answers #
-    ###########
-    
-    # Paginated answers for this user.
+    # Answers by this user.
     def answers(options={})
-      parse_answers(request(singular(id) + "answers", options))
+      self.class.parse_answers(request(singular(user_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))
+    # Badges awarded to user.
+    def badges(options={})
+      self.class.parse_badges(request(singular(user_id) + "/badges", options))
     end
-
-    ############
-    # Comments #
-    ############
     
-    # Paginated comments for this user.
+    # Comments by 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))
+      self.class.parse_comments(request(singular(user_id) + "/comments", 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))
+    # Comments by this user, mentioning another user
+    def comments_mentioning_user(other_user_id, options={})
+      self.class.parse_comments(request(singular(user_id) + "/comments/#{other_user_id}", 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.
+    # Favorites of this user.
     def favorites(options={})
-      parse_questions(request(singular(id) + "favorites", options))
-    end
-
-    def newest_favorites(options={})
-      parse_questions(request(singular(id) + "favorites/newest", options))
+      self.class.parse_questions(request(singular(user_id) + "/favorites", 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))
+    
+    # Comments that are directed at user(s).
+    def mentioned(options={})
+      self.class.parse_comments(request(singular(user_id) + "/mentioned", options))
     end
 
+    # Questions by user(s).
     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))
+      self.class.parse_questions(request(singular(user_id) + "/questions", options))
     end
 
-    def mentioned(options={})
-      parse_comments(request(singular(id) + "mentioned", options))
-    end
-    
-    def badges(options={})
-      parse_badges(request(singular(id) + "badges", options))
+    # Reputation changes for user(s).
+    def rep_changes(options={})
+      self.class.parse_rep_changes(request(singular(user_id) + "/reputation", options))
     end
     
+    # Tags participated in by user(s).
     def tags(options={})
-      parse_tags(request(singular(id) + "tags", options))
+      self.class.parse_tags(request(singular(user_id) + "/tags", options))
     end
 
-    alias_method :mentions, :mentioned
-
+    # Timeline of actions by user(s).
     def timeline(options={})
-      parse_user_timeline(request(singular(id) + "timeline", options))
+      self.class.parse_user_timeline(request(singular(user_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