basic functionality as before: mostly untested

Gemfile

@@ -4,18 +4,12 @@ gem 'rake'
 
 gem 'sinatra'
 
-gem 'activerecord'
-
 gem 'yajl-ruby'
 
-gem 'ancestry'
-
 gem 'sqlite3'
 
 gem 'ampex'
 
-gem 'thumbs_up', :git => "git@github.com:dementrock/thumbs_up.git"
-
 # ruby-mongo-driver
 gem 'mongo', "1.6.2"
 gem 'bson'
@@ -24,7 +18,7 @@ gem 'bson_ext'
 gem 'mongoid', "~> 2.4.0"
 
 gem 'mongoid-tree'
-gem 'voteable_mongo'
+gem 'voteable_mongo', :git => 'https://github.com/dementrock/voteable_mongo.git'
 
 group :test do
   gem 'rspec'

Rakefile

@@ -3,6 +3,7 @@ require 'mongo'
 require 'mongoid'
 require 'yaml'
 require 'logger'
+require 'active_support/all'
 require 'sinatra'
 require 'mongoid/tree'
 require 'voteable_mongo'
@@ -21,7 +22,9 @@ namespace :db do
     require_relative 'models/comment.rb'
     require_relative 'models/comment_thread.rb'
     require_relative 'models/user.rb'
+    require_relative 'models/commentable.rb'
 
+    Commentable.delete_all
     Comment.delete_all
     CommentThread.delete_all
     User.delete_all
@@ -33,27 +36,26 @@ namespace :db do
     user = User.create!(external_id: "1")
 
     def generate_comments(commentable_type, commentable_id, level_limit, user)
+      commentable = Commentable.create!(commentable_type: commentable_type, commentable_id: commentable_id)
       5.times do
-        comment_thread = CommentThread.new(
+        comment_thread = commentable.comment_threads.new(
                           commentable_type: commentable_type, commentable_id: commentable_id,
                           body: "This is a post", title: "Post No.#{rand(10)}",
                           course_id: "1")
         comment_thread.author = user
         comment_thread.save!
         3.times do
-          comment = Comment.new(body: "top comment", course_id: "1")
-          comment.comment_thread = comment_thread
+          comment = comment_thread.comments.new(body: "top comment", course_id: "1")
           comment.author = user
           comment.endorsed = [true, false].sample
           comment.save!
         end
-        100.times do
+        10.times do
           comment = Comment.where(comment_thread_id: comment_thread.id).reject{|c| c.depth >= level_limit}.sample
-          sub_comment = Comment.new(body: "comment body", course_id: "1")
+          sub_comment = comment.children.new(body: "comment body", course_id: "1")
           sub_comment.author = user
           sub_comment.endorsed = [true, false].sample
           sub_comment.save!
-          comment.children << sub_comment
         end
         puts "Generating a comment thread for #{commentable_type} No.#{commentable_id}"
       end
@@ -61,28 +63,27 @@ namespace :db do
 
     generate_comments("questions" , 1, level_limit, user)
     generate_comments("questions" , 2, level_limit, user)
-    generate_comments("questions" , 3, level_limit, user)
     generate_comments("courses"   , 1, level_limit, user)
     generate_comments("lectures"  , 1, level_limit, user)
     generate_comments("lectures"  , 2, level_limit, user)
-    generate_comments("lectures"  , 3, level_limit, user)
-=begin
+
     puts "voting"
     users = []
-    (1..20).each do |id|
+    (1..10).each do |id|
       users << User.find_or_create_by(external_id: id.to_s)
     end
 
-    current = 0
-    total = Comment.count
+    CommentThread.all.each do |c|
+      (0...10).each do |i|
+        users[i].vote(c, [:up, :down].sample)
+      end
+    end
+
     Comment.all.each do |c|
-      (0...20).each do |i|
+      (0...10).each do |i|
         users[i].vote(c, [:up, :down].sample)
       end
-      current += 1
-      puts "voted #{current}/#{total}"
     end
-=end
 
     end_time = Time.now
 

app.rb

 require 'rubygems'
-require 'yajl'
-require 'active_record'
+require 'mongo'
+require 'mongoid'
+require 'yaml'
+require 'logger'
+require 'active_support/all'
 require 'sinatra'
-require 'thumbs_up'
+require 'mongoid/tree'
+require 'voteable_mongo'
 
 require_relative 'models/comment'
 require_relative 'models/comment_thread'
-require_relative 'models/vote'
+require_relative 'models/commentable'
 require_relative 'models/user'
 
 env_index = ARGV.index("-e")
 env_arg = ARGV[env_index + 1] if env_index
 env = env_arg || ENV["SINATRA_ENV"] || "development"
-databases = YAML.load_file("config/database.yml")
+
+Mongoid.load!("config/mongoid.yml")
+Mongoid.logger.level = Logger::INFO
+
 config = YAML.load_file("config/application.yml")
-ActiveRecord::Base.establish_connection(databases[env])
-
-# retrive all comments of a commentable object
-get '/api/v1/commentables/:commentable_type/:commentable_id/comments' do |commentable_type, commentable_id|
-  comment_thread = CommentThread.find_or_create_by_commentable_type_and_commentable_id(commentable_type, commentable_id)
-  if params["to_depth"]
-    comment_thread.json_comments(to_depth: params["to_depth"].to_i)
-  else
-    comment_thread.json_comments
-  end
+
+# DELETE /api/v1/commentables/:commentable_type/:commentable_id
+
+# GET /api/v1/commentables/:commentable_type/:commentable_id/comment_threads
+# POST /api/v1/commentables/:commentable_type/:commentable_id/comment_threads
+#
+# GET /api/v1/comment_threads/:comment_thread_id
+# PUT /api/v1/comment_threads/:comment_thread_id
+# POST /api/v1/comment_threads/:comment_thread_id/comments
+# DELETE /api/v1/comment_threads/:comment_thread_id
+#
+# GET /api/v1/comments/:comment_id
+# PUT /api/v1/comments/:comment_id
+# POST /api/v1/comments/:comment_id
+# DELETE /api/v1/comments/:comment_id
+#
+# PUT /api/v1/votes/comments/:comment_id/users/:user_id
+# DELETE /api/v1/votes/comments/:comment_id/users/:user_id
+#
+# PUT /api/v1/votes/comment_threads/:comment_thread_id/users/:user_id
+# DELETE /api/v1/votes/comment_threads/:comment_thread_id/users/:user_id
+#
+# GET /api/v1/users/:user_id/feeds
+# POST /api/v1/users/:user_id/feeds/subscribe
+#
+
+
+
+# DELETE /api/v1/commentables/:commentable_type/:commentable_id
+# delete the commentable object and all of its associated comment threads and comments
+
+delete '/api/v1/commentables/:commentable_type/:commentable_id' do |commentable_type, commentable_id|
+  commentable = Commentable.find_or_create_by(commentable_type: commentable_type, commentable_id: commentable_id)
+  commentable.destroy
+  commentable.to_hash.to_json
 end
 
-# create a new top-level comment
-post '/api/v1/commentables/:commentable_type/:commentable_id/comments' do |commentable_type, commentable_id|
-  comment_thread = CommentThread.find_or_create_by_commentable_type_and_commentable_id(commentable_type, commentable_id)
-  comment_params = params.select {|key, value| %w{body title user_id course_id}.include? key}.merge({:comment_thread_id => comment_thread.id})
-  comment = comment_thread.root_comments.create(comment_params)
-  if comment.valid?
-    comment.to_json
-  else
-    error 400, comment.errors.to_json
-  end
+# GET /api/v1/commentables/:commentable_type/:commentable_id/comment_threads
+# get all comment threads associated with a commentable object
+# additional parameters accepted: recursive
+
+get '/api/v1/commentables/:commentable_type/:commentable_id/comment_threads' do |commentable_type, commentable_id|
+  commentable = Commentable.find_or_create_by(commentable_type: commentable_type, commentable_id: commentable_id)
+  commentable.comment_threads.map{|t| t.to_hash(recursive: params["recursive"])}.to_json
 end
 
-# delete a commentable object and its associated comments
-delete '/api/v1/commentables/:commentable_type/:commentable_id' do |commentable_type, commentable_id|
-  comment_thread = CommentThread.find_by_commentable_type_and_commentable_id(commentable_type, commentable_id)
-  if comment_thread.nil?
-    error 400, {:error => "commentable object does not exist"}.to_json
-  else
-    comment_thread.destroy
-    comment_thread.to_json
-  end
+# POST /api/v1/commentables/:commentable_type/:commentable_id/comment_threads
+# create a new comment thread for the commentable object
+
+post '/api/v1/commentables/:commentable_type/:commentable_id/comment_threads' do |commentable_type, commentable_id|
+  commentable = Commentable.find_or_create_by(commentable_type: commentable_type, commentable_id: commentable_id)
+  comment_thread = commentable.comment_threads.new(params.slice(*%w[title body course_id]))
+  comment_thread.author = User.find_or_create_by(external_id: params["user_id"])
+  comment_thread.save!
+  comment_thread.to_hash.to_json
 end
 
-# create a new subcomment (reply to comment) only if the comment is NOT a super comment
-post '/api/v1/comments/:comment_id' do |comment_id|
-  comment = Comment.find_by_id(comment_id)
-  if comment.nil? or comment.is_root?
-    error 400, {:error => "invalid comment id"}.to_json
-  elsif comment.depth >= config["level_limit"]
-    error 400, {:error => "depth limit exceeded"}.to_json
-  else
-    comment_params = params.select {|key, value| %w{body title user_id course_id}.include? key}.merge({:comment_thread_id => comment.comment_thread_id})
-    sub_comment = comment.children.create(comment_params)
-    if sub_comment.valid?
-      sub_comment.to_json
-    else
-      error 400, sub_comment.errors.to_json
-    end
-  end
+# GET /api/v1/comment_threads/:comment_thread_id
+# get information of a single comment thread
+# additional parameters accepted: recursive
+
+get '/api/v1/comment_threads/:comment_thread_id' do |comment_thread_id|
+  comment_thread = CommentThread.find(comment_thread_id)
+  comment_thread.to_hash(recursive: params["recursive"]).to_json
+end
+
+# PUT /api/v1/comment_threads/:comment_thread_id
+# update information of comment thread
+
+put '/api/v1/comment_threads/:comment_thread_id' do |comment_thread_id|
+  comment_thread = CommentThread.find(comment_thread_id)
+  comment_thread.update!(params.slice(*%w[title body endorsed])).to_hash.to_json
+end
+
+# POST /api/v1/comment_threads/:comment_thread_id/comments
+# create a comment to the comment thread
+post '/api/v1/comment_threads/:comment_thread_id/comments' do |comment_thread_id|
+  comment_thread = CommentThread.find(comment_thread_id)
+  comment = comment_thread.comments.new(params.slice(*%w[body course_id]))
+  comment.author = User.find_or_create_by(external_id: params["user_id"])
+  comment.save!
+  comment.to_hash.to_json
+end
+
+# DELETE /api/v1/comment_threads/:comment_thread_id
+# delete the comment thread and its comments
+
+delete '/api/v1/comment_threads/:comment_thread_id' do |comment_thread_id|
+  comment_thread = CommentThread.find(comment_thread_id)
+  comment_thread.destroy
+  comment_thread.to_hash.to_json
 end
 
-# get the information of a single comment
+# GET /api/v1/comments/:comment_id
+# retrieve information of a single comment
+# additional parameters accepted: recursive
+
 get '/api/v1/comments/:comment_id' do |comment_id|
-  comment = Comment.find_by_id(comment_id)
-  if comment.nil? or comment.is_root?
-    error 400, {:error => "invalid comment id"}.to_json
-  else
-    if params["recursive"] == "true"
-      if params["to_depth"]
-        comment.to_hash_tree(to_depth: params["to_depth"].to_i).to_json
-      else
-        comment.to_hash_tree.to_json
-      end
-    else
-      comment.to_json
-    end
-  end
+  comment = Comment.find(comment_id)
+  comment.to_hash(recursive: params["recursive"]).to_json
+end
+
+# PUT /api/v1/comments/:comment_id
+# update information of the comment
+
+put '/api/v1/comments/:comment_id' do |comment_id|
+  comment = Comment.find(comment_id)
+  comment.update!(params.slice(*%w[body endorsed])).to_hash.to_json
 end
 
-# delete the comment and the associated sub comments only if the comment is NOT the super comment
+# POST /api/v1/comments/:comment_id
+# create a sub comment to the comment
+
+post '/api/v1/comments/:comment_id' do |comment_id|
+  comment = Comment.find(comment_id)
+  sub_comment = comment.children.new(params.slice(*%w[body]))
+  sub_comment.author = User.find_or_create_by(external_id: params["user_id"])
+  sub_comment.save!
+  sub_comment.to_hash.to_json
+end
+
+# DELETE /api/v1/comments/:comment_id
+# delete the comment and its sub comments
+
 delete '/api/v1/comments/:comment_id' do |comment_id|
-  comment = Comment.find_by_id(comment_id)
-  if comment.nil? or comment.is_root?
-    error 400, {:error => "invalid comment id"}.to_json
-  else
+  comment = Comment.find(comment_id)
   comment.destroy
-    comment.to_json
-  end
+  comment.to_hash.to_json
 end
 
-# update the body / title (or both) of a comment provided the comment is NOT the super comment
-put '/api/v1/comments/:comment_id' do |comment_id|
-  comment = Comment.find_by_id(comment_id)
-  if comment.nil? or comment.is_root?
-    error 400, {:error => "invalid comment id"}.to_json
-  else
-    comment_params = params.select {|key, value| %w{body title endorsed}.include? key}
-    if comment.update_attributes(comment_params)
-      comment.to_json
-    else
-      error 400, comment.errors.to_json
-    end
-  end
-end
+# PUT /api/v1/votes/comments/:comment_id/users/:user_id
+# create or update the vote on the comment
 
-# create or update the vote on the comment by the user
 put '/api/v1/votes/comments/:comment_id/users/:user_id' do |comment_id, user_id|
-  if not %w{up down}.include? params["value"]
-    error 400, {:error => "value must be up or down"}.to_json
-  else
-    comment = Comment.find_by_id(comment_id)
-    if comment.nil?
-      error 400, {:error => "invalid comment id"}.to_json
-    else
-      if %w[up down].include? params["value"]
-        user = User.find_or_create_by_id(user_id)
-        vote = user.vote(comment, { :direction => (params["value"] == "up" ? :up : :down ), :exclusive => :true})
-        comment.to_json
-      else
-        error 400, {:error => "value must be up or down"}.to_json
-      end
-    end
-  end
+  comment = Comment.find(comment_id)
+  user = User.find_or_create_by(external_id: user_id)
+  user.vote(comment, params["value"].intern)
 end
 
-# undo the vote on the comment by the user
+# DELETE /api/v1/votes/comments/:comment_id/users/:user_id
+# unvote on the comment
+
 delete '/api/v1/votes/comments/:comment_id/users/:user_id' do |comment_id, user_id|
-  user = User.find_by_id(user_id.to_i)
-  comment = Comment.find_by_id(comment_id)
-  if user and comment and not comment.is_root?
-    vote = user.unvote_for(comment)
-    comment.to_json
-  else
-    error 400, {:error => "invalid user or comment id"}.to_json
-  end
+  comment = Comment.find(comment_id)
+  user = User.find_or_create_by(external_id: user_id)
+  user.unvote(comment)
+end
+
+# PUT /api/v1/votes/comment_threads/:comment_thread_id/users/:user_id
+# create or update the vote on the comment thread
+
+put '/api/v1/votes/comment_threads/:comment_thread_id/users/:user_id' do |comment_thread_id, user_id|
+  comment_thread = CommentThread.find(comment_thread_id)
+  user = User.find_or_create_by(external_id: user_id)
+  user.vote(comment_thread, params["value"].intern)
+end
+
+# DELETE /api/v1/votes/comment_threads/:comment_thread_id/users/:user_id
+# unvote on the comment thread
+
+delete '/api/v1/votes/comment_threads/:comment_thread_id/users/:user_id' do |comment_thread_id, user_id|
+  comment_thread = CommentThread.find(comment_thread_id)
+  user = User.find_or_create_by(external_id: user_id)
+  user.unvote(comment_thread)
 end
 
 if env.to_s == "development"
   get '/api/v1/clean' do
     Comment.delete_all
     CommentThread.delete_all
-    Vote.delete_all
+    Commentable.delete_all
+    User.delete_all
     {}.to_json
   end
 end

models/comment.rb

-require 'mongoid'
-
 class Comment
   include Mongoid::Document
   include Mongoid::Tree
@@ -18,10 +16,45 @@ class Comment
   attr_accessible :body, :course_id
 
   validates_presence_of :body
-  validates_presence_of :course_id
-  validates_presence_of :author
+  validates_presence_of :course_id # do we really need this?
+  #validates_presence_of :author # allow anonymity?
 
   before_destroy :delete_descendants
   #after_create :create_feeds
   
+  def self.hash_tree(nodes)
+    nodes.map{|node, sub_nodes| node.to_hash.merge("children" => hash_tree(sub_nodes).compact)}
+  end
+
+  def subtree
+    arrange(descendants.order_by([[:parent_ids, :asc], [:created_at, :asc]]))
+  end
+
+  def to_hash(params={})
+    doc = as_document.slice(*%w[body course_id endorsed _id]).
+                      merge("user_id" => author.external_id).
+                      merge("votes" => votes.slice(*%w[count up_count down_count point]))
+    if params[:recursive]
+      doc = doc.merge("children" => self.class.hash_tree(subtree))
+    end
+    doc
+  end
+
+private
+  # adopted and modified from https://github.com/stefankroes/ancestry/blob/master/lib/ancestry/class_methods.rb 
+  def arrange(nodes)
+    # Get all nodes ordered by ancestry and start sorting them into an empty hash
+    nodes.inject(ActiveSupport::OrderedHash.new) do |arranged_nodes, node|
+      # Find the insertion point for that node by going through its ancestors
+      node.parent_ids.inject(arranged_nodes) do |insertion_point, parent_id|
+        insertion_point.each do |parent, children|
+          # Change the insertion point to children if node is a descendant of this parent
+          insertion_point = children if parent_id == parent._id
+        end
+        insertion_point
+      end[node] = ActiveSupport::OrderedHash.new
+      arranged_nodes
+    end
+  end
+
 end

models/comment_thread.rb

@@ -8,21 +8,28 @@ class CommentThread
   field :title, type: String
   field :body, type: String
   field :course_id, type: String, index: true
-  field :commentable_id, type: String
-  field :commentable_type, type: String
 
   belongs_to :author, class_name: "User", index: true
+  belongs_to :commentable, index: true
   has_many :comments, dependent: :destroy # Use destroy to envoke callback on the top-level comments
 
-  attr_accessible :title, :body, :course_id, :commentable_id, :commentable_type
+  attr_accessible :title, :body, :course_id
 
   validates_presence_of :title
   validates_presence_of :body
-  validates_presence_of :course_id
-  validates_presence_of :commentable_id
-  validates_presence_of :commentable_type
+  validates_presence_of :course_id # do we really need this?
+  #validates_presence_of :author #allow anonymity?
   
-  index [:commentable_type, :commentable_id]
   #after_create :create_feeds
   
+  def to_hash(params={})
+    doc = as_document.slice(*%w[title body course_id _id]).
+                      merge("user_id" => author.external_id).
+                      merge("votes" => votes.slice(*%w[count up_count down_count point]))
+    if params[:recursive]
+      doc = doc.merge("children" => comments.map{|c| c.to_hash(recursive: true)})
+    end
+    doc
+  end
+
 end

models/commentable.rb

+class Commentable
+  include Mongoid::Document
+  
+  field :commentable_type, type: String
+  field :commentable_id, type: String
+
+  has_many :comment_threads, dependent: :destroy
+
+  attr_accessible :commentable_type, :commentable_id
+
+  validates_presence_of :commentable_type
+  validates_presence_of :commentable_id
+  validates_uniqueness_of :commentable_id, scope: :commentable_type
+
+  index [:commentable_type, :commentable_id]
+
+  def to_hash
+    as_document
+  end
+
+end

models/user.rb

@@ -3,7 +3,9 @@ class User
   include Mongo::Voter
 
   field :external_id, type: String
+
   has_many :comments
+  has_many :commentable
 
   attr_accessible :external_id
 

spec/app_spec.rb

@@ -2,12 +2,87 @@ require 'spec_helper'
 require 'yajl'
 
 describe "app" do
-  describe "comments" do
   before :each do
     Comment.delete_all
     CommentThread.delete_all
+    Commentable.delete_all
+    User.delete_all
+    
+    commentable = Commentable.create!(commentable_type: "questions", commentable_id: "1")
+
+    user = User.create!(external_id: "1")
+
+    comment_thread = commentable.comment_threads.create!(title: "I can't solve this problem", body: "can anyone help me?", course_id: "1")
+    comment_thread.author = user
+    comment_thread.save!
+
+    comment = comment_thread.comments.create!(body: "this problem is so easy", course_id: "1")
+    comment.author = user
+    comment.save!
+    comment = comment.children.create!(body: "not for me!", course_id: "1")
+    comment.author = user
+    comment.save!
+    comment = comment_thread.comments.create!(body: "see the textbook on page 69. it's quite similar", course_id: "1")
+    comment.author = user
+    comment.save!
+    comment = comment.children.create!(body: "thank you!", course_id: "1")
+    comment.author = user
+    comment.save!
+
+    comment_thread = commentable.comment_threads.create!(title: "This problem is wrong", body: "it is unsolvable", course_id: "2")
+    comment_thread.author = user
+    comment_thread.save!
+
+    comment = comment_thread.comments.create!(body: "how do you know?", course_id: "1")
+    comment.author = user
+    comment.save!
+    comment = comment.children.create!(body: "because blablabla", course_id: "1")
+    comment.author = user
+    comment.save!
+    comment = comment_thread.comments.create!(body: "no wonder I can't solve it", course_id: "1")
+    comment.author = user
+    comment.save!
+    comment = comment.children.create!(body: "+1", course_id: "1")
+    comment.author = user
+    comment.save!
+
+    Comment.all.each do |c|
+      (1..10).each do |id|
+        User.find_or_create_by(external_id: id.to_s).vote(c, [:up, :down].sample)
+      end
+    end
+    CommentThread.all.each do |c|
+      (1..10).each do |id|
+        User.find_or_create_by(external_id: id.to_s).vote(c, [:up, :down].sample)
+      end
+    end
+  end
+
+  describe "comments" do
+    
+    describe "GET /api/v1/commentables/:commentable_type/:commentable_id/comment_threads" do
+      it "get all comment threads associated with a commentable object" do
+        get "/api/v1/commentables/questions/1/comment_threads"
+        last_response.should be_ok
+        comment_threads = Yajl::Parser.parse last_response.body
+        comment_threads.length.should == 2
+        comment_threads.index{|c| c["body"] == "can anyone help me?"}.should_not be_nil
+        comment_threads.index{|c| c["body"] == "it is unsolvable"}.should_not be_nil
       end
-    describe "POST on /api/v1/commentables/:commentable_type/:commentable_id/comments" do
+      it "get all comment threads and comments associated with a commentable object" do
+        get "/api/v1/commentables/questions/1/comment_threads", recursive: true
+        last_response.should be_ok
+        comment_threads = Yajl::Parser.parse last_response.body
+        comment_threads.length.should == 2
+        comment_threads.index{|c| c["body"] == "can anyone help me?"}.should_not be_nil
+        comment_threads.index{|c| c["body"] == "it is unsolvable"}.should_not be_nil
+        comment_thread = comment_threads.first
+        comment_thread["children"].length.should == 2
+      end
+    end
+
+=begin
+    describe "POST on /api/v1/commentables/:commentable_type/:commentable_id/comment_threads" do
       it "should create a top-level comment with correct body, title, user_id, and course_id" do
         post "/api/v1/commentables/questions/1/comments", :body => "comment body", :title => "comment title", :user_id => 1, :course_id => 1
         last_response.should be_ok
@@ -293,5 +368,6 @@ describe "app" do
         last_response.should be_ok
       end
     end
+=end
   end
 end