disqus_api 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 133d31109b75e6a7a8a3948ae883667b419c9d41
+  data.tar.gz: 2316f34bd676de9379991a8f5f260db9fe17307b
+SHA512:
+  metadata.gz: b7c188e126d73f1f8b4a4b2f7b07fbd872ce6552d0f26b55d5ae2349b86906c54bbb7dfd06b3737380a7b695e862a8f7dd416b6dcba7db499312ff3dabc57ab0
+  data.tar.gz: 4b45529a2925f8cfd95e82b8e760c5d03ec4036995af60d06aaf999eb6613fe2825077e40301a6b7861fb9de31972d2de7c02194fd9bd1dabf2e301bea83dcd7

data/.gitignore

@@ -0,0 +1,10 @@
+*.gem
+.yardoc
+rdoc
+coverage
+.bundle
+.ruby-version
+.rvmrc
+.idea
+Gemfile.lock
+spec/config/disqus.yml

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - "1.9.3"
+  - "2.0.0"

data/Gemfile

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+gemspec
+
+group :test do
+  gem "rspec"
+end

data/README.md

@@ -0,0 +1,113 @@
+# Disqus API for Ruby
+[![Gem Version](https://badge.fury.io/rb/disqus_api.png)](http://badge.fury.io/rb/disqus_api)
+[![Build Status](https://travis-ci.org/einzige/disqus_api.png?branch=master)](https://travis-ci.org/einzige/disqus_api)
+
+Provides clean Disqus REST API for your Ruby app. Currently supported API version: 3.0.
+
+## Install
+
+```bash
+gem install disqus_api
+```
+
+## Configure
+
+```ruby
+DisqusApi.config = {api_secret: 'secret key',
+                    api_key: 'public key',
+                    access_token: 'token from app settings'}
+```
+
+## Enjoy
+
+```ruby
+DisqusApi.v3.users.details
+# => {"code" => 0, "response" => {
+#                     "isFollowing"=>false,
+#                     "isFollowedBy"=>false, "connections"=>{}, "isPrimary"=>true, "id"=>"84792962"
+#                     ...
+#                  }
+```
+
+Use response to get response body
+
+```ruby
+DisqusApi.v3.users.details.response
+# => {
+#       "isFollowing"=>false,
+#       "isFollowedBy"=>false, "connections"=>{}, "isPrimary"=>true, "id"=>"84792962"
+#       ...
+#    }
+```
+
+Alias `#body` for response body
+
+```ruby
+DisqusApi.v3.users.details.body
+# => {
+#       "isFollowing"=>false,
+#       "isFollowedBy"=>false, "connections"=>{}, "isPrimary"=>true, "id"=>"84792962"
+#       # ...
+#    }
+```
+
+Setting additional parameters to a query
+
+```ruby
+DisqusApi.v3.posts.list(forum: 'my_form')
+```
+
+### Fetching full collections
+
+By default Disqus API limits returning collections by 25 records per requests. The maximum limit you can set is 100.
+In order to fetch **all records** from a collection use `#all` method:
+
+```ruby
+DisqusApi.v3.posts.list(forum: 'my_form').all
+```
+
+### Pagination
+
+```ruby
+first_page  = DisqusApi.v3.posts.list(forum: 'my_forum', limit: 10)
+
+second_page = first_page.next
+third_page  = second_page.next
+# ...
+```
+
+### Performing custom requests
+
+```ruby
+DisqusApi.v3.get('posts/list.json', forum: 'my_forum')
+DisqusApi.v3.post('posts/create.json', forum: 'my_forum')
+```
+
+### Using in test environment
+
+Disqus API uses Faraday gem, refer to its documentation for details.
+
+```ruby
+before :all do
+  # You can move this block in RSpec initializer or `spec_helper.rb`
+
+  stubbed_request = Faraday::Adapter::Test::Stubs.new do |stub|
+    stub.get('/api/3.0/users/details.json') { [200, {}, {code: 0, body: {response: :whatever}}.to_json] }
+  end
+  DisqusApi.adapter = [:test, stubbed_requests]
+end
+
+it 'performs requests' do
+  DisqusApi.v3.users.details['code'].should == 0
+end
+```
+
+## Contributing to disqus_api
+
+- Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+- Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+- Fork the project
+- Start a feature/bugfix branch
+- Commit and push until you are happy with your contribution
+- Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+- Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.

data/Rakefile

@@ -0,0 +1,6 @@
+#!/usr/bin/env rake
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new :spec
+task default: :spec
+

data/disqus_api.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{disqus_api}
+  s.version = "0.0.2"
+
+  s.date = %q{2013-12-09}
+  s.authors = ["Sergei Zinin"]
+  s.email = %q{szinin@gmail.com}
+  s.homepage = %q{http://github.com/einzige/disqus_api}
+
+  s.licenses = ["MIT"]
+
+  s.files = `git ls-files`.split("\n")
+  s.require_paths = ["lib"]
+  s.extra_rdoc_files = ["README.md"]
+
+  s.description = %q{Provides clean Disqus API for your Ruby app with a nice interface.}
+  s.summary = %q{Disqus API for Ruby}
+
+  s.add_runtime_dependency 'activesupport', ">= 3.0.0"
+  s.add_runtime_dependency 'faraday', ">= 0.8"
+  s.add_runtime_dependency 'faraday_middleware', ">= 0.9"
+  s.add_development_dependency 'bundler'
+end
+

data/lib/apis/3.0.yml

@@ -0,0 +1,79 @@
+exports:
+  exportForum: post
+users:
+  listActiveForums: get
+  listActiveThreads: get
+  listFollowing: get
+  listForums: get
+  unfollow: post
+  listPosts: get
+  details: get
+  listFollowers: get
+  follow: post
+  listActivity: get
+  listMostActiveForums: get
+imports:
+  list: get
+  details: get
+posts:
+  restore: post
+  spam: post
+  unhighlight: post
+  listPopular: get
+  create: post
+  list: get
+  remove: post
+  getContext: get
+  vote: post
+  details: get
+  report: post
+  highlight: post
+  approve: post
+blacklists:
+  add: post
+  list: get
+  remove: post
+reports:
+  domains: get
+  ips: get
+  threads: get
+  users: get
+whitelists:
+  add: post
+  list: get
+  remove: post
+applications:
+  listUsage: get
+trends:
+  listThreads: get
+threads:
+  restore: post
+  vote: post
+  open: post
+  create: post
+  list: get
+  listMostLiked: get
+  listHot: get
+  update: post
+  listSimilar: get
+  details: get
+  listByDate: get
+  listPosts: get
+  close: post
+  remove: post
+  listPopular: get
+forums:
+  create: post
+  listCategories: get
+  listThreads: get
+  listUsers: get
+  listMostLikedUsers: get
+  details: get
+  listPosts: get
+  listModerators: get
+categories:
+  listPosts: get
+  listThreads: get
+  create: post
+  list: get
+  details: get

data/lib/disqus_api.rb

@@ -0,0 +1,46 @@
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/core_ext/object/try'
+require 'yaml'
+require 'json'
+require 'faraday'
+require 'faraday_middleware'
+
+require 'disqus_api/api'
+require 'disqus_api/namespace'
+require 'disqus_api/request'
+require 'disqus_api/response'
+
+module DisqusApi
+
+  def self.adapter
+    @adapter || Faraday.default_adapter
+  end
+
+  def self.adapter=(value)
+    @adapter = value
+  end
+
+  # @return [ActiveSupport::HashWithIndifferentAccess]
+  def self.config
+    @config || raise("No configuration specified for Disqus")
+  end
+
+  # @param [Hash] config
+  # @option config [String] :api_secret
+  # @option config [String] :api_key
+  # @option config [String] :access_token
+  def self.config=(config)
+    @config = ActiveSupport::HashWithIndifferentAccess.new(config)
+  end
+
+  # @param [String] version
+  # @return [Api]
+  def self.init(version)
+    Api.new(version, YAML.load_file(File.join(File.dirname(__FILE__), "apis/#{version}.yml")))
+  end
+
+  # @return [Api]
+  def self.v3
+    @v3 ||= init('3.0')
+  end
+end

data/lib/disqus_api/api.rb

@@ -0,0 +1,80 @@
+module DisqusApi
+  class InvalidApiRequestError < Exception
+    def initialize(response, message = response.inspect)
+      super(response)
+    end
+  end
+
+  class Api
+    DEFAULT_VERSION = '3.0'
+    attr_reader :version, :endpoint, :specifications, :namespaces
+
+    # @param [String] version
+    # @param [Hash] specifications API specifications
+    def initialize(version = DEFAULT_VERSION, specifications = {})
+      @version = version
+      @endpoint = "https://disqus.com/api/#@version/".freeze
+      @specifications = ActiveSupport::HashWithIndifferentAccess.new(specifications)
+
+      @namespaces = ActiveSupport::HashWithIndifferentAccess.new
+      @specifications.keys.each do |namespace|
+        @namespaces[namespace] = Namespace.new(self, namespace)
+      end
+    end
+
+    # @return [Hash]
+    def connection_options
+      {
+        headers: { 'Accept' => "application/json", 'User-Agent' => "DisqusAgent"},
+        ssl: { verify: false },
+        url: @endpoint
+      }
+    end
+
+    # @return [Faraday::Connection]
+    def connection
+      Faraday.new(connection_options) do |builder|
+        builder.use Faraday::Request::Multipart
+        builder.use Faraday::Request::UrlEncoded
+        builder.use Faraday::Response::ParseJson
+
+        builder.params.merge!(DisqusApi.config)
+
+        builder.adapter(*DisqusApi.adapter)
+      end
+    end
+
+    # Performs custom GET request
+    # @param [String] path
+    # @param [Hash] arguments
+    def get(path, arguments = {})
+      perform_request { connection.get(path, arguments).body }
+    end
+
+    # Performs custom POST request
+    # @param [String] path
+    # @param [Hash] arguments
+    def post(path, arguments = {})
+      perform_request { connection.post(path, arguments).body }
+    end
+
+    # DisqusApi.v3.---->>[users]<<-----.details
+    #
+    # Forwards calls to API declared in YAML
+    def method_missing(method_name, *args)
+      namespaces[method_name] or raise(ArgumentError, "No such namespace #{method_name}")
+    end
+
+    def respond_to?(method_name, include_private = false)
+      namespaces[method_name] || super
+    end
+
+    private
+
+    def perform_request
+      yield.tap do |response|
+        raise InvalidApiRequestError.new(response) if response['code'] != 0
+      end
+    end
+  end
+end

data/lib/disqus_api/namespace.rb

@@ -0,0 +1,44 @@
+module DisqusApi
+  class Namespace
+    attr_reader :api, :name, :specification
+
+    # @param [Api] api
+    # @param [String, Symbol] name
+    def initialize(api, name)
+      @api = api
+      @name = name
+      @specification = @api.specifications[@name]
+      @specification or raise(ArgumentError, "No such namespace <#@name>")
+    end
+
+    # @param [String, Symbol] action
+    # @param [Hash] arguments Action params
+    # @return [Request]
+    def build_action_request(action, arguments = {})
+      Request.new(api, name, action, arguments)
+    end
+
+    # @param [String, Symbol, Hash] action
+    # @param [Hash] arguments
+    # @return [Hash] response
+    def request_action(action, arguments = {})
+      build_action_request(action, arguments).response
+    end
+    alias_method :perform_action, :request_action
+
+    # DisqusApi.v3.users.---->>[details]<<-----
+    #
+    # Forwards all API calls under a specific namespace
+    def method_missing(method_name, *args)
+      if specification.has_key?(method_name.to_s)
+        request_action(method_name, *args)
+      else
+        raise NoMethodError, "No action #{method_name} registered for #@name namespace"
+      end
+    end
+
+    def respond_to?(method_name, include_private = false)
+      specification[method_name.to_s] || super
+    end
+  end
+end

data/lib/disqus_api/request.rb

@@ -0,0 +1,50 @@
+module DisqusApi
+  class Request
+    attr_reader :api, :path, :namespace, :action, :arguments, :type
+
+    # @param [Class<DisqusApi::Api>] api
+    # @param [String] namespace
+    # @param [String] action
+    # @param [Hash] arguments Request parameters
+    def initialize(api, namespace, action, arguments = {})
+      @api = api
+      @namespace = namespace.to_s
+      @action = action.to_s
+      @path = "#@namespace/#@action.json"
+
+      # Request type GET or POST
+      namespace_specification = @api.specifications[@namespace] or raise(ArgumentError, "No such namespace: #@namespace")
+      @type = namespace_specification[@action].try(:to_sym) or raise(ArgumentError, "No such API path: #@path")
+
+      # Set request parameters
+      @arguments = arguments
+    end
+
+    # Returns Disqus API response proxy
+    # @param [Symbol] request_type
+    # @param [Hash] arguments
+    # @return [String]
+    def response(arguments = {})
+      Response.new(self, arguments)
+    end
+
+    # Returns plain JSON response received from Disqus
+    # @param [Hash] arguments
+    # @return [String]
+    def perform(arguments = {})
+      case type.to_sym
+      when :post, :get
+        api.public_send(type, path, @arguments.merge(arguments))
+      else
+        raise ArgumentError, "Unregistered request type #{request_type}"
+      end
+    end
+
+    # @see #initialize
+    # @param [String, Symbol] request_type
+    # @return [Hash]
+    def self.perform(*args)
+      self.new(*args).perform
+    end
+  end
+end

data/lib/disqus_api/response.rb

@@ -0,0 +1,55 @@
+module DisqusApi
+  class Response < ActiveSupport::HashWithIndifferentAccess
+    attr_reader :request, :arguments, :content
+
+    # @param [Request] request
+    # @param [Hash] arguments
+    def initialize(request, arguments = {})
+      @request   = request
+      @arguments = arguments
+      @content   = request.perform(@arguments)
+
+      super(@content)
+    end
+
+    # Fetches all records going through pagination
+    # @return [Array<Hash>]
+    def all
+      [].tap do |result|
+        next_response = self
+
+        while next_response
+          result.concat(next_response.body)
+          next_response = next_response.next
+        end
+      end
+    end
+
+    # @return [Response, nil]
+    def next
+      if has_next?
+        request.response(arguments.merge(cursor: next_cursor))
+      end
+    end
+
+    def has_next?
+      self['cursor']['hasNext']
+    end
+
+    # @return [String]
+    def next_cursor
+      self['cursor']['next']
+    end
+
+    # @return [Hash]
+    def body
+      self['response']
+    end
+    alias_method :response, :body
+
+    # @return [Integer]
+    def code
+      self['code']
+    end
+  end
+end

data/spec/config/disqus.yml.example

@@ -0,0 +1,3 @@
+api_secret: ''
+api_key: ''
+access_token: ''

data/spec/disqus_api/api_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+describe DisqusApi::Api do
+  subject(:api) { described_class.new(version, specifications) }
+
+  let(:version) { '3.0' }
+  let(:specifications) { {'users' => 'details'} }
+
+  its(:version) { should == version }
+  its(:specifications) { should == specifications }
+  its(:namespaces) { should have_key(:users) }
+  its(:endpoint) { should == 'https://disqus.com/api/3.0/' }
+  it { should respond_to(:users) }
+  its(:users) { should be_a(DisqusApi::Namespace) }
+  its(:connection_options) { should == {headers: {"Accept"=>"application/json", "User-Agent"=>"DisqusAgent"},
+                                        ssl: {verify: false},
+                                        url: "https://disqus.com/api/3.0/"} }
+
+  describe "unregistered namespace metacalls" do
+    it { should_not respond_to(:foo) }
+    specify { expect { api.foo }.to raise_error(ArgumentError) }
+  end
+
+  describe "#connection" do
+    subject { api.connection }
+    it { should be_a(Faraday::Connection) }
+    its(:params) { should have_key('api_key') }
+    its(:params) { should have_key('api_secret') }
+    its(:params) { should have_key('access_token') }
+  end
+
+  describe "#get", perform_requests: true do
+    let(:request_path) { '/api/3.0/users/details.json' }
+
+    it 'performs GET request' do
+      api.get(request_path)['code'].should == 0
+    end
+
+    context "invalid request" do
+      let(:request_path) { '/api/3.0/invalid/request.json' }
+      let(:response_code) { 1 }
+
+      specify do
+        expect { api.get(request_path) }.to raise_error(DisqusApi::InvalidApiRequestError, /"code"=>1/)
+      end
+    end
+  end
+
+  describe "#post", perform_requests: true do
+    let(:request_type) { :post }
+    let(:request_path) { '/api/3.0/forums/create.json' }
+
+    context local: true do
+      it 'performs POST request' do
+        api.post(request_path)['code'].should == 0
+      end
+    end
+
+    context "invalid request" do
+      let(:request_path) { '/api/3.0/invalid/request.json' }
+      let(:response_code) { 1 }
+
+      specify do
+        expect { api.post(request_path) }.to raise_error(DisqusApi::InvalidApiRequestError, /"code"=>1/)
+      end
+    end
+  end
+end

data/spec/disqus_api/namespace_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe DisqusApi::Namespace do
+  let(:api) { DisqusApi::Api.new(version, specifications) }
+  let(:version) { '3.0' }
+  let(:specifications) { {'users' => {'details' => 'get'}} }
+
+  let(:namespace_name) { 'users' }
+  subject(:namespace) { described_class.new(api, namespace_name) }
+
+  its(:api) { should == api }
+  its(:specification) { should == {'details' => 'get'} }
+  its(:name) { should == namespace_name }
+
+  it { should respond_to :details }
+
+  describe "#initialize" do
+    let(:namespace_name) { 'foos' }
+    it { expect { subject }.to raise_error(ArgumentError, "No such namespace <foos>") }
+  end
+
+  describe "#build_action_request" do
+    subject(:request) { namespace.build_action_request('details', {args: true}) }
+    its(:path) { should == 'users/details.json' }
+    its(:api) { should == api }
+    its(:arguments) { should == {args: true} }
+  end
+
+  context perform_requests: true do
+    let(:request_path) { '/api/3.0/users/details.json' }
+
+    its(:details) { should be_a(Hash) }
+    its(:details) { should be_a(::DisqusApi::Response) }
+
+    it 'performs requests' do
+      namespace.details['code'].should == 0
+    end
+
+    describe "#request_action" do
+      let(:response) { namespace.request_action('details') }
+
+      it 'performs action request' do
+        response['code'].should == 0
+      end
+
+      context "invalid request" do
+        let(:response) { namespace.request_action('foos') }
+        specify { expect { response }.to raise_error(ArgumentError) }
+        specify { expect { namespace.foos }.to raise_error(NoMethodError) }
+      end
+    end
+  end
+end

data/spec/disqus_api/request_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe DisqusApi::Request do
+  subject(:request) { described_class.new(api, namespace, action, arguments) }
+  let(:api) { DisqusApi::Api.new(version, specifications) }
+  let(:version) { '3.0' }
+  let(:specifications) { {'users' => {'details' => 'get'}} }
+  let(:namespace) { 'users' }
+  let(:action) { 'details' }
+  let(:arguments) { {} }
+
+  its(:api) { should == api }
+  its(:namespace) { should == namespace }
+  its(:action) { should == action }
+  its(:path) { should == 'users/details.json' }
+  its(:type) { should == :get }
+  its(:arguments) { should == arguments }
+  its(:response) { should be_a(Hash) }
+  its(:response) { should be_a(::DisqusApi::Response) }
+  its(:response) { should have_key('code') }
+
+  describe "#initialize" do
+    context "invalid namespace" do
+      let(:namespace) { 'foo' }
+      specify { expect { subject }.to raise_error(ArgumentError) }
+    end
+
+    context "invalid action" do
+      let(:action) { 'foo' }
+      specify { expect { subject }.to raise_error(ArgumentError) }
+    end
+  end
+
+  describe "#perform" do
+    it 'sends request through API' do
+      request.perform['code'].should == 0
+    end
+  end
+
+  describe ".perform" do
+    it 'sends request through API' do
+      described_class.perform(api, namespace, action, arguments)['code'].should == 0
+    end
+  end
+end

data/spec/disqus_api/response_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe DisqusApi::Response do
+  let(:request) { DisqusApi::Request.new(api, namespace, action, request_arguments) }
+  let(:api) { DisqusApi::Api.new(version, specifications) }
+  let(:version) { '3.0' }
+  let(:specifications) { {'posts' => {'list' => 'get'}} }
+  let(:namespace) { 'posts' }
+  let(:action) { 'list' }
+  let(:request_arguments) { {forum: 'my_forum'} }
+
+  subject(:response) { described_class.new(request, arguments) }
+  let(:arguments) { {limit: 1} }
+  let(:response_body) { {} }
+
+  before do
+    request.should_receive(:perform).with(arguments).and_return(response_body)
+  end
+
+  describe "#has_next?" do
+    context "has" do
+      let(:response_body) { {'cursor' => {'hasNext' => true}} }
+      its(:has_next?) { should be_true }
+    end
+
+    context 'has not' do
+      let(:response_body) { {'cursor' => {'hasNext' => false}} }
+      its(:has_next?) { should be_false }
+    end
+  end
+
+  describe "#next_cursor" do
+    let(:response_body) { {'cursor' => {'next' => 'next identifier'}} }
+    its(:next_cursor) { should == 'next identifier' }
+  end
+
+  describe "#body" do
+    let(:response_body) { {'response' => {'received' => true}} }
+    its(:body) { should == {'received' => true} }
+  end
+
+  describe "#code" do
+    let(:response_body) { {'code' => 0} }
+    its(:code) { should == 0}
+  end
+
+  describe "#next" do
+    context "has next page" do
+      let(:response_body) { {'cursor' => {'hasNext' => true, 'next' => 'Next:2'}} }
+      let(:next_page_response) { double('next_page_response') }
+
+      before do
+        request.should_receive(:response).with({limit: 1, cursor: 'Next:2'}).and_return(next_page_response)
+      end
+
+      its(:next) { should == next_page_response }
+    end
+
+    context 'has no next page' do
+      let(:response_body) { {'cursor' => {'hasNext' => false, 'next' => 'Next:2'}} }
+      its(:next) { should be_nil }
+    end
+  end
+
+  describe "#all" do
+    let(:response_body) { {'cursor' => {'hasNext' => false, 'next' => 'Next:2'}, 'response' => ['page_1_elem_1']} }
+    its(:all) { should == ['page_1_elem_1'] }
+
+    context "many pages" do
+      let(:response_body) { {'cursor' => {'hasNext' => true, 'next' => 'Next:2'}, 'response' => ['page_1_elem_1']} }
+      let(:next_page_response) { double('next_page_response') }
+
+      before do
+        request.should_receive(:response).with({limit: 1, cursor: 'Next:2'}).and_return(next_page_response)
+        next_page_response.should_receive(:body).and_return(['page_2_elem_1'])
+        next_page_response.should_receive(:next).and_return(nil)
+      end
+
+      its(:all) { should == ['page_1_elem_1', 'page_2_elem_1'] }
+    end
+  end
+end

data/spec/disqus_api_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe DisqusApi, perform_requests: true do
+  describe "user details" do
+    let(:request_path) { '/api/3.0/users/details.json' }
+
+    it 'performs requests' do
+      DisqusApi.v3.users.details['code'].should == 0
+    end
+  end
+
+  describe "posts list", local: true do
+    before :each do
+      stubbed_requests.get("/api/3.0/posts/list.json?forum=my_forum&access_token=&api_key=&api_secret=&limit=1")          { [200, {}, {code: 0, response: ['first_one'],  cursor: {hasNext: true,  next: 1}}.to_json] }
+      stubbed_requests.get("/api/3.0/posts/list.json?cursor=1&forum=my_forum&access_token=&api_key=&api_secret=&limit=1") { [200, {}, {code: 0, response: ['second_one'], cursor: {hasNext: true,  next: 2}}.to_json] }
+      stubbed_requests.get("/api/3.0/posts/list.json?cursor=2&forum=my_forum&access_token=&api_key=&api_secret=&limit=1") { [200, {}, {code: 0, response: ['third_one'],  cursor: {hasNext: false, next: 3}}.to_json] }
+      stubbed_requests.get("/api/3.0/posts/list.json?cursor=3&forum=my_forum&access_token=&api_key=&api_secret=&limit=1") { [200, {}, {code: 0, response: ['fourth_one'], cursor: {hasNext: false         }}.to_json] }
+    end
+
+    it 'fetches all comments' do
+      DisqusApi.v3.posts.list(forum: 'my_forum', limit: 1).all.should == %w{first_one second_one third_one}
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,42 @@
+require 'disqus_api'
+
+def load_disqus_config(fname)
+  DisqusApi.config = YAML.load_file(File.join(File.dirname(__FILE__), "config/#{fname}"))
+end
+
+if ENV['USE_DISQUS_ACCOUNT']
+  load_disqus_config("disqus.yml")
+else
+  load_disqus_config("disqus.yml.example")
+
+  shared_context "perform requests", perform_requests: true do
+    before do
+      @all_requests_local = true
+    end
+
+    let(:request_path) { '' }
+    let(:response_body) { nil }
+    let(:response_code) { 0 }
+    let(:request_type) { :get }
+
+    let(:stubbed_requests) do
+      Faraday::Adapter::Test::Stubs.new do |stub|
+        stub.public_send(request_type, request_path) { [200, {}, {code: response_code, body: response_body}.to_json] }
+      end
+    end
+
+    before :each do
+      DisqusApi.adapter = [:test, stubbed_requests]
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+  config.color_enabled = true
+  config.formatter = :documentation
+
+  if ENV['USE_DISQUS_ACCOUNT']
+    config.filter_run_excluding local: true
+  end
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: disqus_api
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Sergei Zinin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-12-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: faraday_middleware
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Provides clean Disqus API for your Ruby app with a nice interface.
+email: szinin@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- README.md
+- Rakefile
+- disqus_api.gemspec
+- lib/apis/3.0.yml
+- lib/disqus_api.rb
+- lib/disqus_api/api.rb
+- lib/disqus_api/namespace.rb
+- lib/disqus_api/request.rb
+- lib/disqus_api/response.rb
+- spec/config/disqus.yml.example
+- spec/disqus_api/api_spec.rb
+- spec/disqus_api/namespace_spec.rb
+- spec/disqus_api/request_spec.rb
+- spec/disqus_api/response_spec.rb
+- spec/disqus_api_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/einzige/disqus_api
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.5
+signing_key: 
+specification_version: 4
+summary: Disqus API for Ruby
+test_files: []