ideaoforder-acts_as_disqusable 0.4.0

data/lib/acts_as_disqusable/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/acts_as_disqusable/forum.rb

@@ -0,0 +1,118 @@
+module Disqus
+  class Forum
+    
+    attr_accessor :id, :shortname, :name, :created_at, :description
+    def initialize(data)
+      data.each { |k, v| send(:"#{k}=", v) }
+    end
+    
+    def self.all
+      @@all ||= begin
+        response = get('/get_forum_list')
+        response["succeeded"] ? response["message"].map { |data| Disqus::Forum.new(data) } : nil
+      end
+    end
+    
+    def self.find(id)
+      id = id.to_s if !id.is_a? String
+      grouped = self.all.group_by(&:id)
+      grouped[id].first if grouped[id]
+    end
+    
+    # Returns the forum API Key for this forum.
+    def key(user_api_key = nil)
+      @key ||= begin
+        response = self.class.get('/get_forum_api_key', :query => {
+          :api_key => user_api_key,
+          :forum_id => id 
+        })
+        response["succeeded"] ? response["message"] : nil
+      end
+    end
+    
+    # Returns an array of threads belonging to this forum.
+    def self.threads(id, key)
+      response = self.get('/get_thread_list', :query => { 
+        :forum_api_key => key, 
+        :forum_id => id 
+      })
+      response["succeeded"] ? response["message"].map { |data| Disqus::Thread.new(data) } : nil
+    end
+    
+    def threads
+      self.class.threads(self.id, self.key)
+    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 self.get_thread_by_url(url, key)
+      response = self.get('/get_thread_by_url', :query => { :url => url, :forum_api_key => key })
+      response["succeeded"] ? Thread.new(response["message"]) : nil
+    end
+    
+    def get_thread_by_url(url)
+      self.class.get_thread_by_url(url, self.key)
+    end
+
+    def self.thread_by_identifier(identifier, title, key)
+      response = self.post('/thread_by_identifier', :query => { 
+        :forum_api_key => key,
+        :identifier => identifier,
+        :title => title 
+      })
+      
+      response["succeeded"] ? Thread.new(response["message"]["thread"]) : nil
+    end
+    
+     def thread_by_identifier(identifier, title)
+       self.class.thread_by_identifier(identifier, title, self.key)
+     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 self.update_thread(thread_id, key, opts = {})
+      response = self.post('/update_thread', :query => opts.merge(:forum_api_key  => key))
+      response["succeeded"]
+    end
+    
+    def update_thread(thread_id, opts = {})
+      self.class.update_thread(thread_id, self.key, opts = {})
+    end
+    
+    def self.posts_count(thread_ids, key)
+      response = self.get('/get_num_posts', :query => { :thread_ids => thread_ids, :forum_api_key  => key })
+      out = Hash.new
+      response["message"].each { |id, data| out[id] = data.first }
+      if out.length == 1
+        return out.values.first
+      else
+        return out
+      end
+    end
+    
+    def posts_count(thread_ids)
+      self.class.posts_count(thread_ids, self.key)
+    end
+
+    # Returns an array of posts belonging to this thread.
+    def self.posts(key, opts={:exclude => 'spam'})
+      response = self.get('/get_forum_posts', :query => opts.merge(:forum_api_key  => key ))
+      out = Hash.new
+      response["message"].map { |data| Disqus::Post.new(data) }
+    end
+    
+    def posts(opts={:exclude => 'spam'})
+      self.class.posts(self.key)
+    end
+  end
+end

data/lib/acts_as_disqusable/post.rb

@@ -0,0 +1,31 @@
+module Disqus
+  class Post
+    attr_accessor :id, :forum, :thread, :created_at, :message, :parent_post, :shown, :is_anonymous, :anonymous_author, :author, :points, :status, :has_been_moderated, :ip_address
+    def initialize(data)
+      data.each { |k, v| send(:"#{k}=", v) }
+    end
+    
+    def author_name
+      if is_anonymous
+        anonymous_author["name"]
+      else
+        author["display_name"] || author["username"]
+      end
+    end
+    
+    def linked_author(opts={})
+      "<a href=\"#{author['url']}\" target=\"#{opts[:target]}\" class=\"#{opts[:class]}\">#{self.author_name}</a>"
+    end
+    
+    def self.create(opts={})
+      response = self.class.post('/create_post', :query => opts)
+      if response["success"]
+        Disqus::Post.new(response["message"])
+      else
+        nil
+      end
+    end
+  end
+end
+
+

data/lib/acts_as_disqusable/thread.rb

@@ -0,0 +1,38 @@
+module Disqus
+  class Thread
+    attr_accessor :id, :forum, :slug, :title, :created_at, :allow_comments, :url, :identifier, :hidden, :category
+    def initialize(data)
+      data.each { |k, v| send(:"#{k}=", v) }
+    end
+    
+    def self.find_or_create(title, identifier)
+      response = self.post('/thread_by_identifier', :body => { :title => title, :identifier => identifier }.merge(self.default_params))
+      Disqus::Thread.new(response["message"]["thread"])
+    end
+    
+    def posts_count
+      response = self.class.get('/get_num_posts', :query => { :thread_ids => id })
+      response["message"][id].first.to_i
+    end
+
+    # Returns an array of posts belonging to this thread.
+    # limit — Number of entries that should be included in the response. Default is 25.
+    # start — Starting point for the query. Default is 0.
+    # filter — Type of entries that should be returned (new, spam or killed).
+    # exclude — Type of entries that should be excluded from the response (new, spam or killed).    
+    def self.posts(thread_id, opts={:exclude => 'spam'})
+      response = self.get('/get_thread_posts', :query => opts.merge(:thread_id => thread_id ))
+      response["message"].map { |data| Disqus::Post.new(data) }
+    end
+    
+    def posts(opts={:exclude => 'spam'})
+      self.class.posts(self.id)
+    end
+    
+    # Sets the provided values on the thread object.
+    def update(opts = {})
+      result = self.class.post('/update_thread', :query => opts.merge(:forum_api_key  => forum.key))
+      return result["succeeded"]
+    end
+  end
+end

data/lib/disqus.rb

@@ -0,0 +1,52 @@
+# == From the {Disqus Website}[http://disqus.com]:
+ 
+# "Disqus, pronounced "discuss", is a service and tool for web comments and
+# discussions. The Disqus comment system can be plugged into any website, blog,
+# or application. Disqus makes commenting easier and more interactive, while
+# connecting websites and commenters across a thriving discussion community."
+#
+# "Disqus is a free service to the general public with absolutely no inline
+# advertisements."
+ 
+# The Disqus gem helps you quickly and easily integrate Disqus's Javascript
+# widgets into your Ruby-based website. Adding Disqus to your site literally
+# takes only a few minutes. The Disqus gem also provides a complete
+# implementation of the Disqus API for more complex applications.
+ 
+# To use this code, please first create an account on Disqus[http://disqus.com].
+require 'rubygems'
+require 'httparty'
+ 
+require 'acts_as_disqusable/forum'
+require 'acts_as_disqusable/thread'
+require 'acts_as_disqusable/post'
+require 'acts_as_disqusable/author'
+ 
+module Disqus
+  @defaults = {
+    :api_key => "",
+    :account => "",
+    :developer => false,
+    :api_version => '1.1',
+    :container_id => 'disqus_thread',
+    :avatar_size => 48,
+    :num_items => 5,
+    :forum_api_key => '', # optional--if you're just mapping one forum to your app, this is convenient
+    :forum_shortname => '', # ditto
+    :forum_id => '' # ditto
+  }
+ 
+  def self.defaults
+    @config = @defaults.merge(YAML::load(File.open("#{RAILS_ROOT}/config/disqus.yml")))
+  end
+  
+  [Author, Forum, Post, Thread].each do |klass|
+    klass.class_eval "include HTTParty"
+    klass.class_eval "base_uri 'http://disqus.com/api'"
+    klass.class_eval "format :json"
+    klass.class_eval "default_params :user_api_key => '#{self.defaults[:api_key]}'"
+    klass.class_eval "default_params :forum_api_key => '#{self.defaults[:forum_api_key]}'"
+    klass.class_eval "default_params :forum_id => '#{self.defaults[:forum_id]}'"
+    klass.class_eval "default_params :api_version => '#{self.defaults[:api_version]}'"
+  end
+end

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.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