disqus 0.1.1 → 1.0.0

data/lib/disqus/author.rb

@@ -0,0 +1,27 @@
+module Disqus
+
+  class BaseAuthor
+    attr_reader :url, :email_hash
+  end
+
+  class Author < BaseAuthor
+    attr_reader :id, :username, :display_name, :has_avatar
+    def initialize(id, username, display_name, url, email_hash, has_avatar)
+      @id, @username, @display_name, @url, @email_hash, @has_avatar = id, username, display_name, url, email_hash, has_avatar
+    end
+
+    # Returns the user's <tt>display_name</tt> or <tt>username</tt> if <tt>display_name</tt> is blank.
+    def name
+      @display_name.blank? ? @username : @display_name
+    end
+
+  end
+
+  class AnonymousAuthor < BaseAuthor
+    attr_reader :name
+    def initialize(name, url, email_hash)
+      @name, @url, @email_hash = name, url, email_hash
+    end
+  end
+end
+

data/lib/disqus/forum.rb

@@ -0,0 +1,126 @@
+module Disqus
+
+  class Forum
+    attr_reader :id, :shortname, :name, :created_at, :threads
+    
+    def initialize(id, shortname, name, created_at, include_threads = false)
+      @id, @shortname, @name, @created_at = id.to_i, shortname, name, Time.parse(created_at.to_s)
+      @key = nil
+      @forum_threads = include_threads ? load_threads : []
+    end
+
+    def ==(other_forum)
+      id        == other_forum.id        &&
+      shortname == other_forum.shortname &&
+      name      == other_forum.name      &&
+      key       == other_forum.key
+    end
+
+    # Returns an array of Forum objects belonging to the user indicated by the API key.
+    def self.list(user_api_key = nil)
+      opts = user_api_key ? {:api_key => user_api_key} : {}
+      response = Disqus::Api::get_forum_list(opts)
+      if response["succeeded"]
+        return response["message"].map{|forum| Forum.new(forum["id"], forum["shortname"], forum["name"], forum["created_at"])}
+      else
+        raise_api_error(response)
+      end
+    end
+    
+    # Returns a Forum object corresponding to the given forum_id or nil if it was not found.
+    def self.find(forum_id, user_api_key = nil)
+      opts = user_api_key ? {:api_key => user_api_key} : {}
+      list = Forum.list(opts)
+      if list
+        list.select{|f| f.id == forum_id}.first
+      end
+    end
+    
+    # Returns the forum API Key for this forum.
+    def key(user_api_key = nil)
+      @key ||= load_key(user_api_key)
+    end
+    
+    # Returns an array of threads belonging to this forum.
+    def forum_threads(force_update = false)
+      if (@forum_threads.nil? or @forum_threads.empty? or force_update)
+        @forum_threads = Disqus::Thread.list(self)
+      end
+      @forum_threads
+    end
+    
+    # Returns a thread associated with the given URL.
+    #
+    # A thread will only have an associated URL if it was automatically
+    # created by Disqus javascript embedded on that page.
+    def get_thread_by_url(url)
+      response = Disqus::Api::get_thread_by_url(:url => url, :forum_api_key => key)
+      if response["succeeded"]
+        t = response["message"]
+        Thread.new(t["id"], self, t["slug"], t["title"], t["created_at"], t["allow_comments"], t["url"], t["identifier"])
+      else
+        raise_api_error(response)
+      end
+    end
+    
+    # Create or retrieve a thread by an arbitrary identifying string of your
+    # choice. For example, you could use your local database's ID for the
+    # thread. This method allows you to decouple thread identifiers from the
+    # URL's on which they might be appear. (Disqus would normally use a
+    # thread's URL to identify it, which is problematic when URL's do not
+    # uniquely identify a resource.) If no thread exists for the given
+    # identifier (paired with the forum) yet, one will be created.
+    #
+    # Returns a Thread object representing the thread that was created or
+    # retrieved.
+    def thread_by_identifier(identifier, title)
+      # TODO - should we separate thread retrieval from thread creation? The API to me seems confusing here.
+      response = Disqus::Api::thread_by_identifier(:identifier => identifier, :title => title, :forum_api_key => key)
+      if response["succeeded"]
+        t = response["message"]["thread"]
+        Thread.new(t["id"], self, t["slug"], t["title"], t["created_at"], t["allow_comments"], t["url"], t["identifier"])
+      else
+        raise_api_error(response)
+      end
+    end
+    
+    # Sets the provided values on the thread object.
+    #
+    # Returns an empty success message.
+    #
+    # Options:
+    #
+    # * <tt>:title</tt> - the title of the thread
+    # * <tt>:slug</tt> - the per-forum-unique string used for identifying this thread in disqus.com URL's relating to this thread. Composed of underscore-separated alphanumeric strings.
+    # * <tt>:url</tt> - the URL this thread is on, if known.
+    # * <tt>:allow_comment</tt> - whether this thread is open to new comments
+    def update_thread(thread_id, opts = {})
+      result = Disqus::Api::update_thread(
+        :forum_api_key  => key,
+        :thread_id      => thread_id,
+        :title          => opts[:title],
+        :slug           => opts[:slug],
+        :url            => opts[:url],
+        :allow_comments => opts[:allow_comments]
+      )
+      return result["succeeded"]
+    end
+    
+    private
+    
+    def raise_api_error(response)
+      raise "Error: #{response['code']}: #{response['message']}"
+    end
+    
+    def load_key(user_api_key = nil)
+      opts = user_api_key ? {:api_key => user_api_key} : {}
+      response = Disqus::Api::get_forum_api_key(opts.merge(:forum_id => self.id))
+      if response["succeeded"]
+        return @key = response["message"] 
+      else
+        raise_api_error(response)
+      end
+    end
+    
+  end
+end

data/lib/disqus/post.rb

@@ -0,0 +1,51 @@
+module Disqus
+
+  class Post
+    attr_reader :id, :forum, :thread, :created_at, :message, :parent_post, :shown, :is_anonymous, :author
+    
+    def initialize(id, forum, thread, created_at, message, parent_post, shown, is_anonymous, author)
+         @id, @forum, @thread, @created_at, @message, @parent_post, @shown, @is_anonymous, @author = id.to_i, forum, thread, Time.parse(created_at.to_s), message, parent_post, shown, is_anonymous, author
+    end
+    
+    # Returns an array of Post objects representing all posts belonging to the
+    # given thread. The array is sorted by the "created_at" date descending.
+    def self.list(thread)
+      response = Disqus::Api::get_thread_posts(:thread_id =>thread.id, :forum_api_key => thread.forum.key)
+      if response["succeeded"]
+        posts = response["message"].map do |post|
+          author = nil
+          if post["is_anonymous"] 
+            author = AnonymousAuthor.new(
+              post["anonymous_author"]["name"],
+              post["anonymous_author"]["url"],
+              post["anonymous_author"]["email_hash"]
+            )
+          else
+            author = Author.new(
+              post["author"]["id"].to_i,
+              post["author"]["username"],
+              post["author"]["display_name"],
+              post["author"]["url"],
+              post["author"]["email_hash"],
+              post["author"]["has_avatar"]
+            )
+          end
+          Post.new( 
+            post["id"],
+            thread.forum,
+            thread,
+            post["created_at"],
+            post["message"],
+            post["parent_post"],
+            post["shown"],
+            post["is_anonymous"],
+            author
+          )
+        end
+        posts.sort!{|a,b| a.created_at <=> b.created_at}
+      end
+    end
+  end
+end
+
+

data/lib/disqus/thread.rb

@@ -0,0 +1,73 @@
+module Disqus
+
+  class Thread
+    attr_reader :id, :forum, :slug, :title, :created_at, :allow_comments, :url, :identifier, :forum
+    
+    def initialize(id, forum, slug, title, created_at, allow_comments, url, identifier)
+      @id, @forum, @slug, @title, @created_at, @allow_comments, @url, @identifier = id.to_i, forum, slug, title, Time.parse(created_at.to_s), allow_comments, url, identifier
+      @posts = []
+    end
+
+    # Threads are equal if all their attributes are equal.
+    def ==(other_thread)
+      id             == other_thread.id             &&
+      forum          == other_thread.forum          &&
+      slug           == other_thread.slug           &&
+      title          == other_thread.title          &&
+      created_at     == other_thread.created_at     &&
+      allow_comments == other_thread.allow_comments &&
+      url            == other_thread.url            &&
+      identifier     == other_thread.identifier
+    end
+    
+    # Returns an array of Thread objects representing the threads belonging to the given Forum.
+    def self.list(forum, opts = {})
+      response = Disqus::Api::get_thread_list(opts.merge(:forum_id =>forum.id, :forum_api_key => forum.key))
+      if response["succeeded"]
+        list = response["message"].map do |thread| 
+          Thread.new(
+            thread["id"],
+            forum,
+            thread["slug"],
+            thread["title"],
+            thread["created_at"],
+            thread["allow_comments"],
+            thread["url"],
+            thread["identifier"]
+          )
+        end
+      end
+    end
+
+    # Returns an array of posts belonging to this thread.
+    def posts(force_update = false)
+      if (@posts.nil? or @posts.empty? or force_update)
+        @posts = Disqus::Post.list(self)
+      end
+      @posts
+    end
+    
+    # Sets the provided values on the thread object.
+    #
+    # Options:
+    #
+    # * :thread_id
+    # * :title
+    # * :slug
+    # * :url
+    # * :allow_comments
+    def update(opts = {})
+      result = Disqus::Api::update_thread(opts.merge(
+        :forum_api_key  => forum.key,
+        :thread_id      => id,
+        :title          => title,
+        :slug           => slug,
+        :url            => url,
+        :allow_comments => allow_comments)
+      )
+      return result["succeeded"]
+    end
+    
+  end
+
+end

data/lib/disqus/version.rb

@@ -0,0 +1,8 @@
+module Disqus #:nodoc:
+  module Version #:nodoc:
+    MAJOR = 1
+    MINOR = 0
+    TINY = 0
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/lib/disqus/widget.rb

@@ -59,15 +59,15 @@ module Disqus
         <script type="text/javascript">
         //<[CDATA[
         (function() {
-        		var links = document.getElementsByTagName('a');
-        		var query = '?';
-        		for(var i = 0; i < links.length; i++) {
-        			if(links[i].href.indexOf('#disqus_thread') >= 0) {
-        				query += 'url' + i + '=' + encodeURIComponent(links[i].href) + '&';
-        			}
-        		}
-        		document.write('<script type="text/javascript" src="#{ROOT_PATH}get_num_replies.js' + query + '"></' + 'script>');
-        	})();
+            var links = document.getElementsByTagName('a');
+            var query = '?';
+            for(var i = 0; i < links.length; i++) {
+              if(links[i].href.indexOf('#disqus_thread') >= 0) {
+                query += 'url' + i + '=' + encodeURIComponent(links[i].href) + '&';
+              }
+            }
+            document.write('<' + 'script type="text/javascript" src="#{ROOT_PATH}get_num_replies.js' + query + '"></' + 'script>');
+          })();
         //]]>
         </script>
         WHIMPER

data/tasks/rcov.rake

@@ -0,0 +1,23 @@
+desc "Run RCov"
+task :rcov do
+  run_coverage Dir["test/**/*_test.rb"]
+end
+
+def run_coverage(files)
+  rm_f "coverage"
+  rm_f "coverage.data"
+  if files.length == 0
+    puts "No files were specified for testing"
+    return
+  end
+  files = files.join(" ")
+  if PLATFORM =~ /darwin/
+    exclude = '--exclude "gems/"'
+  else
+    exclude = '--exclude "rubygems"'
+  end
+  rcov = "rcov -Ilib:test --sort coverage --text-report #{exclude} --no-validator-links"
+  cmd = "#{rcov} #{files}"
+  puts cmd
+  sh cmd
+end

data/test/api_test.rb

@@ -0,0 +1,80 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class ApiTest < Test::Unit::TestCase
+  
+  def setup
+    require 'disqus'
+    Disqus.defaults[:api_key] = DISQUS_TEST["api_key"]
+  end
+  
+  def test_create_post
+    mock_post_response('create_post.json')
+    the_post = Disqus::Api::create_post()
+    assert_equal "This is a mock post", the_post["message"]["message"]
+  end
+  
+  def test_get_forum_list
+    mock_get_response('get_forum_list.json')
+    forum_list = Disqus::Api::get_forum_list
+    assert_equal "Disqus Test", forum_list["message"][0]["name"]
+  end
+  
+  def test_get_forum_api_key
+    mock_get_response('get_forum_api_key.json')
+    forum_api_key = Disqus::Api::get_forum_api_key(:forum_id => 1234, :user_api_key=>"FAKE_KEY")
+    assert_equal "FAKE_FORUM_API_KEY", forum_api_key["message"]
+  end
+  
+  def test_get_thread_list
+    mock_get_response('get_thread_list.json')
+    thread_list = Disqus::Api::get_thread_list(:forum_api_key=>"FAKE_KEY")
+    assert_equal "this_is_the_thread_identifier", thread_list["message"].first["identifier"]
+  end
+  
+  def test_get_num_posts
+    mock_get_response('get_num_posts.json')
+    nums = Disqus::Api::get_num_posts(:thread_ids => [123,456], :forum_api_key=>"FAKE_KEY")
+    assert_equal [10,12], nums["message"][nums["message"].keys.first]
+  end
+  
+  def test_get_thread_by_url
+    mock_get_response('get_thread_by_url.json')
+    thread = Disqus::Api::get_thread_by_url(:url => "FAKE_URL", :forum_api_key=>"FAKE_KEY")
+    assert_equal "test_thread", thread["message"]["slug"]
+  end
+  
+  def test_get_thread_posts
+    mock_get_response('get_thread_posts.json')
+    thread_posts = Disqus::Api::get_thread_posts(:thread_id =>1234, :forum_api_key => "FAKE_KEY")
+    assert_equal "This is a mock post", thread_posts["message"].first["message"]
+  end
+  
+  def test_thread_by_identifier
+    mock_post_response('thread_by_identifier.json')
+    thread = Disqus::Api::thread_by_identifier(:identifier =>'foo_bar', :title => "Foo Bar", :forum_api_key => "FAKE_KEY")
+    assert_equal "Test thread", thread["message"]["thread"]["title"]
+  end
+  
+  def test_update_thread
+    mock_post_response('update_thread.json')
+    result = Disqus::Api::thread_by_identifier(:thread_id =>123, :title => "Foo Bar", :forum_api_key => "FAKE_KEY")
+    assert result["succeeded"]
+  end
+  
+  def test_comment_form
+    c = Disqus::Api::comment_form("myforum", "mythread")
+    assert_match(/myforum/, c)
+    assert_match(/mythread/, c)
+  end
+  
+  private
+  
+  def mock_get_response(file)
+    Disqus::Api.expects(:get).returns(File.read(File.dirname(__FILE__) + "/responses/#{file}"))  
+  end
+  
+  def mock_post_response(file)
+    Disqus::Api.expects(:post).returns(File.read(File.dirname(__FILE__) + "/responses/#{file}"))  
+  end
+
+end

data/test/config.yml

@@ -0,0 +1,3 @@
+# This can be used to do actual calls to the API rather than use mocks during
+# testing. This can be useful to verify tests against API changes.
+api_key: 'YOUR DISQUS USER API KEY GOES HERE'

data/test/config.yml.sample

@@ -0,0 +1,3 @@
+# This can be used to do actual calls to the API rather than use mocks during
+# testing. This can be useful to verify tests against API changes.
+api_key: 'YOUR DISQUS USER API KEY GOES HERE'

data/test/forum_test.rb

@@ -0,0 +1,70 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class ForumTest < Test::Unit::TestCase
+  
+  def setup
+    require 'disqus'
+    Disqus.defaults[:api_key] = DISQUS_TEST["api_key"]
+    stub_api_call(:get_forum_api_key).returns("FAKE_FORUM_API_KEY")
+  end
+
+  def test_forum_list
+    mock_api_call(:get_forum_list)
+    list = Disqus::Forum.list
+    expected = [create_forum]
+    assert_equal 1,  list.size
+    assert_equal expected, list
+  end
+
+  def test_forum_find
+    mock_api_call(:get_forum_list)
+    forum = Disqus::Forum.find(1234)
+    assert_equal "disqus-test", forum.shortname
+  end
+
+  def test_forum_find_bad_id
+    mock_api_call(:get_forum_list)
+    forum = Disqus::Forum.find(666)
+    assert_equal nil, forum
+  end
+
+  def test_forum_find_no_forums
+    Disqus::Api.expects(:get_forum_list).returns({"succeeded"=>true, "code"=>"", "message" => []}) 
+    forum = Disqus::Forum.find(1234)
+    assert_equal nil, forum
+  end
+
+  def test_key
+    mock_api_call(:get_forum_api_key)
+    forum = Disqus::Forum.new(1234, "disqus-test", "Disqus Test", "2008-01-03 14:44:07.627492")
+    assert_equal "FAKE_FORUM_API_KEY", forum.key
+  end
+  
+  def test_forum_threads
+    forum = create_forum
+    Disqus::Thread.expects(:list).with(forum).returns([thread = mock()])
+    assert_equal [thread], forum.forum_threads
+  end
+  
+  def test_get_thread_by_url
+    mock_api_call(:get_thread_by_url)
+    forum = create_forum
+    thread = forum.get_thread_by_url("http://www.example.com")
+    expected = Disqus::Thread.new("7651269", forum, "test_thread", "Test thread", "2008-11-28T01:47", true, "FAKE_URL", nil)
+    assert_equal expected, thread
+  end
+  
+  def test_thread_by_identifier
+    mock_api_call(:thread_by_identifier)
+    forum = create_forum
+    thread = forum.thread_by_identifier("FAKE_IDENTIFIER", "")
+    expected = Disqus::Thread.new("7651269", forum, "test_thread", "Test thread", "2008-11-28T01:47", true, "FAKE_URL", "FAKE_IDENTIFIER")
+    assert_equal expected, thread
+  end
+  
+  def test_update_thread
+    Disqus::Api.expects(:update_thread).with({:thread_id => 1234, :forum_api_key => "FAKE_FORUM_API_KEY", :title => 'Title', :slug => "a_slug", :url => "http://www.example.com", :allow_comments => true}).returns({"succeeded" => true})
+    forum = create_forum
+    forum.update_thread(1234, :title => 'Title', :slug => "a_slug", :url => "http://www.example.com", :allow_comments => true)
+  end
+end