goodreads_17up 0.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2ed19533305d447d2c1378fc490cf2bd7daf0a80
+  data.tar.gz: 01b6e36b14bb6720d122a0dfdf01dc42a254ecff
+SHA512:
+  metadata.gz: 6e6f8b2e4291aea73fc0fb9d8ec3ec86d30ae13ba8d702a0d64f5095f006bab2aec161cb21baf46279aee254d54f9ef4231f8ea2e34cfa231d92be28f1805c53
+  data.tar.gz: 5168872ba353b8ecff0920de10392eee28e7bf38badd5c89691fb6a246eb19a34c4efc30b633b4856e4ee2c358de6bd2f81670dbbf7ab83011f418b3d8449b9f

data/.gitignore

@@ -0,0 +1,24 @@
+*.gem
+*.rbc
+*.swp
+*.tmproj
+*~
+.DS_Store
+.\#*
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+\#*
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+tmtags

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--format=nested
+--backtrace

data/.travis.yml

@@ -0,0 +1,6 @@
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - ree
+  - 1.9.3
+  - 2.0.0

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/README.md

@@ -0,0 +1,211 @@
+# Goodreads [![Build Status](https://secure.travis-ci.org/sosedoff/goodreads.png)](http://travis-ci.org/sosedoff/goodreads)
+
+Ruby wrapper to communicate with Goodreads API.
+
+## Installation
+
+Install gem with rubygems:
+
+```
+gem install goodreads
+```
+
+Or manually:
+
+```
+rake install
+```
+
+## Getting Started
+
+Before using Goodreads API you must create a new application. Visit [signup form](http://www.goodreads.com/api/keys) for details.
+
+Setup client:
+
+``` ruby
+client = Goodreads::Client.new(:api_key => 'KEY', :api_secret => 'SECRET')
+client = Goodreads.new(:api_key => 'KEY') # short version
+```
+
+### Global configuration
+
+You can define client credentials on global level. Just create an initializer file (if using rails) under
+`config/initializers`:
+
+``` ruby
+Goodreads.configure(
+  :api_key => 'KEY',
+  :api_secret => 'SECRET'
+)
+```
+
+Get global configuration:
+
+``` ruby
+Goodreads.configuration # => {:api_key => 'YOUR_KEY'}
+```
+
+In case you need to reset options:
+
+```ruby
+Goodreads.reset_configuration
+```
+
+## Usage
+
+### Lookup books
+
+You can lookup a book by ISBN, ID or Title:
+
+```ruby
+client.book('id')
+client.book_by_isbn('ISBN')
+client.book_by_title('Book title')
+```
+
+Search for books (by title, isbn, genre):
+
+```ruby
+search = client.search_books('The Lord Of The Rings')
+
+search.results.work.each do |book|
+  book.id        # => book id
+  book.title     # => book title
+end
+```
+
+### Authors
+ 
+Look up an author by their Goodreads Author ID:
+
+```ruby
+author = client.author('id')
+
+author.id              # => author id
+author.name            # => author's name
+author.link            # => link to author's Goodreads page
+author.fans_count      # => number of fans author has on Goodreads
+author.image_url       # => link to image of the author
+author.small_image_url # => link to smaller of the author
+author.about           # => description of the author
+author.influences      # => list of links to author's influences
+author.works_count     # => number of works by the author in Goodreads
+author.gender          # => author's gender
+author.hometown        # => author's hometown
+author.born_at         # => author's birthdate
+author.died_at         # => date of author's death
+```
+
+Look up an author by name:
+
+```ruby
+author = client.author_by_name('Author Name')
+
+author.id     # => author id
+author.name   # => author name
+author.link   # => link to author's Goodreads page
+```
+
+### Reviews
+
+Pull recent reviews:
+
+```ruby
+client.recent_reviews.each do |r|
+  r.id            # => review id
+  r.book.title    # => review book title
+  r.body          # => review message
+  r.user.name     # => review user name
+end
+```
+
+Get review details:
+
+```ruby
+review = client.review('id')
+
+review.id         # => review id
+review.user       # => user information
+review.book       # => uook information
+review.rating     # => user rating
+```
+
+### Shelves
+
+Get the books on a user's shelf:
+
+```ruby
+shelf = client.shelf(user_id, shelf_name)
+
+shelf.books  # array of books on this shelf
+shelf.start  # start index of this page of paginated results
+shelf.end    # end index of this page of paginated results
+shelf.total  # total number of books on this shelf
+```
+
+### Groups
+
+Get group details:
+
+```ruby
+group = client.group('id')
+
+group.id                 # => group id
+group.title              # => group title
+group.access             # => group's access settings
+                         # => (e.g., public or private)
+group.group_users_count  # => number of users in the group
+```
+
+List the groups a given user is a member of:
+
+```ruby
+group_list = client.group_list('user_id', 'sort')
+
+group_list.total         # => total number of groups
+group_list.group.count  # => number of groups returned in the request
+
+# Loop through the list to get details for each of the groups.
+
+group_list.group.each do |g|
+  g.id                 # => group id
+  g.access             # => access settings (private, public)
+  g.users_count        # => number of members
+  g.title              # => title
+  g.image_url          # => url of the group's image
+  g.last_activity_at   # => date and time of the group's last activity
+end
+```
+
+The `sort` parameter is optional, and defaults to `my_activity`. For other sorting options, [see here](http://www.goodreads.com/api#group.list).
+
+### OAuth
+
+For API calls requiring permission, such as write operations or browsing friends, see our [OAuth tutorial](examples/oauth.md).
+
+## Testing
+
+To run the test suite:
+
+```
+rake test
+```
+
+## Contributions
+
+You're welcome to submit patches and new features.
+
+- Create a new branch for your feature of bugfix
+- Add tests so it does not break any existing code
+- Open a new pull request
+- Check official [API documentation](http://www.goodreads.com/api)
+
+## License
+
+Copyright © 2011-2013 Dan Sosedoff.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler'
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:test) do |t|
+  t.pattern = 'spec/*_spec.rb'
+  t.verbose = false
+end
+
+task :default => :test

data/examples/oauth.md

@@ -0,0 +1,57 @@
+# Authorizing Goodreads via OAuth
+
+For services requiring permission, such as write operations or browsing friends, the client must be authorized through OAuth.
+
+## Request Tokens vs. Access Tokens
+
+First, get an OAuth *request* token:
+
+```ruby
+request_token = OAuth::Consumer.new(
+  Goodreads.configuration[:api_key],
+  Goodreads.configuration[:api_secret],
+  :site => 'http://www.goodreads.com'
+).get_request_token
+```
+
+Next, authorize by opening the authorization URL in a browser:
+
+```ruby
+request_token.authorize_url
+```
+
+Then request an OAuth *access* token:
+
+```ruby
+access_token = request_token.get_access_token
+```
+
+Finally, initialize a Goodreads client with it:
+
+```ruby
+goodreads_client = Goodreads.new :oauth_token => access_token
+```
+
+For more info, see the [Goodreads documentation](http://www.goodreads.com/api/oauth_example).
+
+## User ID
+
+Get the ID of the user who authorized via OAuth:
+
+```ruby
+goodreads_client.user_id
+```
+
+## Friends
+
+Get the friend details for a user:
+
+```ruby
+friends_hash = goodreads_client.friends [user_id]
+```
+
+Get a list of their names:
+
+```ruby
+friends_hash.user.map{ |u| u.name }
+```

data/goodreads.gemspec

@@ -0,0 +1,28 @@
+require File.expand_path('../lib/goodreads/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "goodreads_17up"
+  s.version     = Goodreads::VERSION.dup
+  s.summary     = "Goodreads API wrapper"
+  s.description = "Simple wrapper for the Goodreads API"
+  s.homepage    = "http://github.com/sosedoff/goodreads"
+  s.authors     = ["Dan Sosedoff"]
+  s.email       = ["dan.sosedoff@gmail.com"]
+  
+  s.add_development_dependency 'webmock',   '~> 1.11'
+  s.add_development_dependency 'rake',      '~> 0.9'
+  s.add_development_dependency 'rspec',     '~> 2.12'
+  s.add_development_dependency 'simplecov', '~> 0.7'
+  s.add_development_dependency 'yard',      '~> 0.6'
+  
+  s.add_runtime_dependency 'rest-client',   '~> 1.6'
+  s.add_runtime_dependency 'hashie',        '~> 1.2'
+  s.add_runtime_dependency 'activesupport', '~> 3'
+  s.add_runtime_dependency 'i18n',          '~> 0.5'
+  s.add_runtime_dependency 'oauth',         '~> 0.4'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{|f| File.basename(f)}
+  s.require_paths = ["lib"]
+end

data/lib/goodreads/client/authorized.rb

@@ -0,0 +1,9 @@
+module Goodreads
+  module Authorized
+
+    def user_id
+      oauth_request('/api/auth_user')['user']['id']
+    end
+
+  end
+end

data/lib/goodreads/client/authors.rb

@@ -0,0 +1,19 @@
+module Goodreads
+  module Authors
+    # Get author details
+    #
+    def author(id, params={})
+      params[:id] = id
+      data = request('/author/show', params)
+      Hashie::Mash.new(data['author'])
+    end
+
+    # Search for an author by name
+    #
+    def author_by_name(name, params={})
+      params[:id] = name
+      data = request('/api/author_url', params)
+      Hashie::Mash.new(data['author'])
+    end
+  end
+end

data/lib/goodreads/client/books.rb

@@ -0,0 +1,35 @@
+module Goodreads
+  module Books
+    # Search for books
+    #
+    # query   - Text to match against book title, author, and ISBN fields.
+    # options - Optional search parameters
+    #
+    # options[:page] - Which page to returns (default: 1)
+    # options[:field] - Search field. One of: title, author, or genre (default is all)
+    #
+    def search_books(query, params={})
+      params[:q] = query.to_s.strip
+      data = request('/search/index', params)
+      Hashie::Mash.new(data['search'])
+    end
+    
+    # Get book details by Goodreads book ID
+    #
+    def book(id)
+      Hashie::Mash.new(request('/book/show', :id => id)['book'])
+    end
+    
+    # Get book details by book ISBN
+    #
+    def book_by_isbn(isbn)
+      Hashie::Mash.new(request('/book/isbn', :isbn => isbn)['book'])
+    end
+    
+    # Get book details by book title
+    #
+    def book_by_title(title)
+      Hashie::Mash.new(request('/book/title', :title => title)['book'])
+    end
+  end
+end

data/lib/goodreads/client/friends.rb

@@ -0,0 +1,12 @@
+module Goodreads
+  module Friends
+    # Get the specified user's friends
+    #
+    # user_id - integer or string
+    #
+    def friends(user_id)
+      data = oauth_request("/friend/user/#{user_id}")
+      Hashie::Mash.new(data['friends'])
+    end
+  end
+end

data/lib/goodreads/client/groups.rb

@@ -0,0 +1,15 @@
+module Goodreads
+  module Groups
+    # Get group details
+    def group(group_id)
+      data = request('/group/show', :id => group_id)
+      Hashie::Mash.new(data['group'])
+    end
+
+    # Get list of groups a given user is a member of
+    def group_list(user_id, sort='my_activity')
+      data = request('/group/list', :id => user_id, :sort => sort)
+      Hashie::Mash.new(data['groups']['list'])
+    end
+  end
+end

data/lib/goodreads/client/reviews.rb

@@ -0,0 +1,24 @@
+module Goodreads
+  module Reviews
+    # Recent reviews from all members.
+    #
+    # params[:skip_cropped] - Select only non-cropped reviews
+    #
+    def recent_reviews(params={})
+      skip_cropped = params.delete(:skip_cropped) || false
+      data = request('/review/recent_reviews', params)
+      if data['reviews'] && data['reviews'].key?('review')
+        reviews = data['reviews']['review'].map { |r| Hashie::Mash.new(r) }
+        reviews = reviews.select { |r| !r.body.include?(r.url) } if skip_cropped
+        reviews
+      end
+    end
+    
+    # Get review details
+    #
+    def review(id)
+      data = request('/review/show', :id => id)
+      Hashie::Mash.new(data['review'])
+    end
+  end
+end

data/lib/goodreads/client/shelves.rb

@@ -0,0 +1,26 @@
+module Goodreads
+  module Shelves
+
+    # Get books from a user's shelf
+    def shelf(user_id, shelf_name, options={})
+      options = options.merge(:shelf => shelf_name, :v =>2)
+      data = request("/review/list/#{user_id}.xml", options)
+      reviews = data['reviews']['review']
+
+      books = []
+      unless reviews.nil?
+        # one-book results come back as a single hash
+        reviews = [reviews] if !reviews.instance_of?(Array) 
+        books = reviews.map {|e| Hashie::Mash.new(e)} 
+      end
+
+      Hashie::Mash.new({
+        :start => data['reviews']['start'].to_i,
+        :end => data['reviews']['end'].to_i,
+        :total => data['reviews']['total'].to_i,
+        :books => books
+      })
+    end
+
+  end
+end

data/lib/goodreads/client/users.rb

@@ -0,0 +1,10 @@
+module Goodreads
+  module Users
+    # Get user details
+    #
+    def user(id)
+      data = request('/user/show', :id => id)
+      Hashie::Mash.new(data['user'])
+    end
+  end
+end

data/lib/goodreads/client.rb

@@ -0,0 +1,41 @@
+require 'goodreads/client'
+require 'goodreads/client/books'
+require 'goodreads/client/reviews'
+require 'goodreads/client/authors'
+require 'goodreads/client/users'
+require 'goodreads/client/shelves'
+require 'goodreads/client/authorized'
+require 'goodreads/client/groups'
+require 'goodreads/client/friends'
+
+module Goodreads
+  class Client
+    include Goodreads::Request
+    include Goodreads::Books
+    include Goodreads::Reviews
+    include Goodreads::Authors
+    include Goodreads::Users
+    include Goodreads::Shelves
+    include Goodreads::Authorized
+    include Goodreads::Groups
+    include Goodreads::Friends
+
+    attr_reader :api_key, :api_secret, :oauth_token
+
+    # Initialize a Goodreads::Client instance
+    #
+    # options[:api_key]     - Account API key
+    # options[:api_secret]  - Account API secret
+    # options[:oauth_token] - OAuth access token (optional, required for some calls)
+    #
+    def initialize(options={})
+      unless options.kind_of?(Hash)
+        raise ArgumentError, "Options hash required."
+      end
+
+      @api_key    = options[:api_key] || Goodreads.configuration[:api_key]
+      @api_secret = options[:api_secret] || Goodreads.configuration[:api_secret]
+      @oauth_token = options[:oauth_token]
+    end
+  end
+end

data/lib/goodreads/errors.rb

@@ -0,0 +1,6 @@
+module Goodreads
+  class Error              < StandardError; end
+  class ConfigurationError < Error ; end
+  class Unauthorized       < Error ; end
+  class NotFound           < Error ; end
+end

data/lib/goodreads/request.rb

@@ -0,0 +1,67 @@
+require 'rest-client'
+require 'active_support/core_ext'
+require 'hashie'
+
+module Goodreads
+  module Request
+    API_URL    = 'http://www.goodreads.com'
+    API_FORMAT = 'xml'
+
+    protected
+
+    # Perform an API request
+    #
+    # path   - Request path
+    # params - Parameters hash
+    #
+    def request(path, params={})
+      token = api_key || Goodreads.configuration[:api_key]
+
+      if token.nil?
+        raise Goodreads::ConfigurationError, 'API key required.'
+      end
+
+      params.merge!(:format => API_FORMAT, :key => token)
+      url = "#{API_URL}#{path}"
+
+      resp = RestClient.get(url, :params => params) do |response, request, result, &block|
+        case response.code
+          when 200
+            response.return!(request, result, &block)
+          when 401
+            raise Goodreads::Unauthorized
+          when 404
+            raise Goodreads::NotFound
+        end
+      end
+
+      parse(resp)
+    end
+
+    # Perform an OAuth API request. Goodreads must have been initialized with a valid OAuth access token.
+    #
+    # path   - Request path
+    # params - Parameters hash
+    #
+    def oauth_request(path, params=nil)
+      raise 'OAuth access token required!' unless @oauth_token
+      path = "#{path}?#{params.map{|k,v|"#{k}=#{v}"}.join('&')}" if params
+      resp = @oauth_token.get(path, {'Accept'=>'application/xml'})
+
+      case resp
+        when Net::HTTPUnauthorized
+          raise Goodreads::Unauthorized
+        when Net::HTTPNotFound
+          raise Goodreads::NotFound
+      end
+
+      parse(resp)
+    end
+
+    def parse(resp)
+      hash = Hash.from_xml(resp.body)['GoodreadsResponse']
+      hash.delete('Request')
+      hash
+    end
+  end
+end

data/lib/goodreads/version.rb

@@ -0,0 +1,5 @@
+module Goodreads
+  unless defined?(Goodreads::VERSION)
+    VERSION = '0.2.1'.freeze
+  end
+end

data/lib/goodreads.rb

@@ -0,0 +1,41 @@
+require 'goodreads/version'
+require 'goodreads/errors'
+require 'goodreads/request'
+require 'goodreads/client'
+
+module Goodreads
+  @@options = {}
+  
+  # Create a new Goodreads::Client instance
+  #
+  def self.new(options={})
+    Goodreads::Client.new(options)
+  end
+  
+  # Define a global configuration
+  #
+  # options[:api_key]    - Account API key
+  # options[:api_secret] - Account API secret
+  #
+  def self.configure(options={})
+    unless options.kind_of?(Hash)
+      raise ArgumentError, "Options hash required."
+    end
+    
+    @@options[:api_key]    = options[:api_key]
+    @@options[:api_secret] = options[:api_secret]
+    @@options
+  end
+  
+  # Returns global configuration hash
+  #
+  def self.configuration
+    @@options
+  end
+  
+  # Resets the global configuration
+  #
+  def self.reset_configuration
+    @@options = {}
+  end
+end

data/spec/authentication_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe 'Client' do
+  before :each do
+    Goodreads.reset_configuration
+  end
+  
+  it 'raises Goodreads::ConfigurationError if API key was not provided' do
+    client = Goodreads::Client.new
+    
+    proc { client.book_by_isbn('0307463745') }.
+      should raise_error Goodreads::ConfigurationError, 'API key required.'
+  end
+    
+  it 'raises Goodreads::Unauthorized if API key is not valid' do
+    client = Goodreads::Client.new(:api_key => 'INVALID_KEY')
+    
+    stub_request(:get, "http://www.goodreads.com/book/isbn?format=xml&isbn=054748250711&key=INVALID_KEY").
+      to_return(:status => 401)
+      
+    proc { client.book_by_isbn('054748250711') }.
+      should raise_error Goodreads::Unauthorized
+  end
+end

data/spec/client_spec.rb

@@ -0,0 +1,296 @@
+require 'spec_helper'
+require 'oauth'
+
+describe 'Client' do
+  let(:client)  { Goodreads::Client.new(:api_key => 'SECRET_KEY') }
+  before(:each) { Goodreads.reset_configuration }
+
+  describe '#new' do
+    it 'requires an argument' do
+      expect { Goodreads::Client.new(nil) }.
+        to raise_error ArgumentError, "Options hash required."
+    end
+
+    it 'requires a hash argument' do
+      expect { Goodreads::Client.new('foo') }.
+        to raise_error ArgumentError, "Options hash required."
+    end
+  end
+
+  describe '#book_by_isbn' do
+    before { stub_with_key_get('/book/isbn', {:isbn => '0307463745'}, 'book.xml') }
+
+    it 'returns a book by isbn' do
+      book = client.book_by_isbn('0307463745')
+
+      book.should respond_to :id
+      book.should respond_to :title
+    end
+
+    context 'when book does not exist' do
+      before do
+        stub_request(:get, "http://www.goodreads.com/book/isbn?format=xml&isbn=123456789&key=SECRET_KEY").
+          to_return(:status => 404, :body => "", :headers => {}) 
+      end
+
+      it 'raises Goodreads::NotFound' do
+        expect { client.book_by_isbn('123456789') }.to raise_error Goodreads::NotFound
+      end
+    end
+  end
+
+  describe '#search_books' do
+    before { stub_with_key_get('/search/index', {:q => 'Rework'}, 'search_books_by_name.xml') }
+
+    it 'returns book search results' do
+      result = client.search_books('Rework')
+
+      result.should be_a Hashie::Mash
+      result.should respond_to :query
+      result.should respond_to :total_results
+      result.should respond_to :results
+      result.results.should respond_to :work
+      result.query.should eq 'Rework'
+      result.results.work.size.should eq 3
+      result.results.work.first.id.should eq 6928276
+    end
+  end
+
+  describe '#book' do
+    before { stub_with_key_get('/book/show', {:id => '6732019'}, 'book.xml') }
+
+    it 'returns a book by goodreads id' do
+      expect { client.book('6732019') }.not_to raise_error
+    end
+  end
+
+  describe '#book_by_title' do
+    before { stub_with_key_get('/book/title', {:title => 'Rework'}, 'book.xml') }
+
+    it 'returns a book by title' do
+      expect { client.book_by_title('Rework') }.not_to raise_error
+    end
+  end
+
+  describe '#recent_reviews' do
+    before { stub_with_key_get('/review/recent_reviews', {}, 'recent_reviews.xml') }
+
+    it 'returns recent reviews' do
+      reviews = client.recent_reviews
+
+      reviews.should be_an Array
+      reviews.should_not be_empty
+      reviews.first.should respond_to :id
+    end
+
+    context 'with :skip_cropped => true' do
+      before { stub_with_key_get('/review/recent_reviews', {}, 'recent_reviews.xml') }
+  
+      it 'returns only full reviews' do
+        reviews = client.recent_reviews(:skip_cropped => true)
+        reviews.should be_an Array
+        reviews.should_not be_empty
+      end
+    end
+  end
+
+  describe '#review' do
+    before { stub_with_key_get('/review/show', {:id => '166204831'}, 'review.xml') }
+
+    it 'returns review details' do
+      review = client.review('166204831')
+
+      review.should be_a Hashie::Mash
+      review.id.should eq '166204831'
+    end
+
+    context 'when review does not exist' do
+      before do
+        stub_request(:get, "http://www.goodreads.com/review/show?format=xml&id=12345&key=SECRET_KEY").
+          to_return(:status => 404, :body => "", :headers => {})
+      end
+
+      it 'raises Goodreads::NotFound' do
+        expect { client.review('12345') }.to raise_error Goodreads::NotFound
+      end
+    end
+  end
+
+  describe '#author' do
+    before { stub_with_key_get('/author/show', {:id => '18541'}, 'author.xml') }
+
+    it 'returns author details' do
+      author = client.author('18541')
+
+      author.should be_a Hashie::Mash
+      author.id.should eq '18541'
+      author.name.should eq "Tim O'Reilly"
+      author.link.should eq 'http://www.goodreads.com/author/show/18541.Tim_O_Reilly'
+      author.fans_count.should eq 109
+      author.image_url.should eq 'http://photo.goodreads.com/authors/1199698411p5/18541.jpg'
+      author.small_image_url.should eq 'http://photo.goodreads.com/authors/1199698411p2/18541.jpg'
+      author.about.should eq '' 
+      author.influences.should eq ''
+      author.works_count.should eq '34'
+      author.gender.should eq 'male'
+      author.hometown.should eq 'Cork'
+      author.born_at.should eq '1954/06/06'
+      author.died_at.should be_nil
+    end
+
+    context 'when author does not exist' do
+      before do
+        stub_request(:get, "http://www.goodreads.com/author/show?format=xml&id=12345&key=SECRET_KEY").
+          to_return(:status => 404, :body => "", :headers => {})
+      end
+
+      it 'raises Goodreads::NotFound' do
+        expect { client.author('12345') }.to raise_error Goodreads::NotFound
+      end
+    end
+  end
+
+  describe '#author_by_name' do
+    before do
+      stub_with_key_get('/api/author_url', {:id => 'Orson Scott Card'}, 'author_by_name.xml')
+    end
+
+    it 'returns author details' do
+      author = client.author_by_name('Orson Scott Card')
+
+      author.should be_a Hashie::Mash
+      author.id.should eq   '589'
+      author.name.should eq 'Orson Scott Card'
+      author.link.should eq 'http://www.goodreads.com/author/show/589.Orson_Scott_Card?utm_medium=api&utm_source=author_link'
+    end
+  end
+
+  describe '#user' do
+    before { stub_with_key_get('/user/show', {:id => '878044'}, 'user.xml') }
+
+    it 'returns user details' do
+      user = client.user('878044')
+
+      user.should be_a Hashie::Mash
+      user.id.should eq '878044'
+      user.name.should eq 'Jan'
+      user.user_name.should eq 'janmt'
+    end
+
+    context 'when user does not exist' do
+      before do
+        stub_request(:get, "http://www.goodreads.com/user/show?format=xml&id=12345&key=SECRET_KEY").
+          to_return(:status => 404, :body => "", :headers => {})
+      end
+
+      it 'raises Goodreads::NotFound' do
+        expect { client.user('12345') }.to raise_error Goodreads::NotFound
+      end
+    end
+  end
+
+  describe '#friends' do
+    before { client.stub(:oauth_request).and_return(Hash.from_xml(fixture('friends.xml'))['GoodreadsResponse']) }
+
+    it 'returns friend details' do
+      friends = client.friends('878044')
+
+      friends.should be_an_instance_of Hashie::Mash
+      friends.should respond_to :user
+      friends.user.size.should eq friends.end.to_i
+      friends.user.first.should respond_to :name
+    end
+  end
+
+  describe '#shelf' do
+    it "returns list of books for a user's specified shelf" do
+      stub_with_key_get('/review/list/1.xml', {:shelf => 'to-read', :v => '2'}, 'to-read.xml')
+
+      shelf = client.shelf('1', 'to-read')
+
+      shelf.should respond_to :start
+      shelf.should respond_to :end
+      shelf.should respond_to :total
+      shelf.should respond_to :books
+
+      shelf.start.should eq 1
+      shelf.end.should eq 20
+      shelf.total.should eq 40
+      shelf.books.length.should eq 20
+      shelf.books.first.id.should eq '45590939'
+      shelf.books.first.book.title.strip.should eq 'The Demon-Haunted World: Science as a Candle in the Dark'
+    end
+
+    it "paginates book lists from a user's shelf" do
+      stub_with_key_get('/review/list/1.xml', {:shelf => 'to-read', :v => '2', :page => '2'}, 'to-read-p2.xml')
+
+      shelf = client.shelf('1', 'to-read', :page => 2)
+
+      shelf.start.should eq 21
+      shelf.end.should eq 40
+      shelf.total.should eq 40
+      shelf.books.length.should eq 20
+      shelf.books.first.id.should eq '107804211'
+      shelf.books.first.book.title.should match /Your Money or Your Life/
+    end
+
+    it "returns an empty array when shelf is empty" do
+      stub_with_key_get('/review/list/1.xml', {:shelf => 'to-read', :v => '2'}, 'empty.xml')
+
+      shelf = client.shelf('1', 'to-read')
+
+      shelf.start.should eq 0
+      shelf.end.should eq 0
+      shelf.total.should eq 0
+      shelf.books.length.should eq 0
+    end
+  end
+
+  describe '#user_id' do
+    let(:consumer) { OAuth::Consumer.new('API_KEY', 'SECRET_KEY', :site => 'http://www.goodreads.com') }
+    let(:token)    { OAuth::AccessToken.new(consumer, 'ACCESS_TOKEN', 'ACCESS_SECRET') }
+
+    before do
+      stub_request(:get, "http://www.goodreads.com/api/auth_user").
+        to_return(:status => 200, :body => fixture('oauth_response.xml'), :headers => {})
+    end
+
+    it 'returns id of the user with oauth authentication' do
+      client = Goodreads::Client.new(:api_key => 'SECRET_KEY', :oauth_token => token)
+      client.user_id.should eq '2003928'
+    end
+  end
+
+  describe '#group' do
+    before { stub_with_key_get('/group/show', {:id => '1'}, 'group.xml') }
+
+    it "returns group details" do
+      group = client.group('1')
+    
+      group.should be_a Hashie::Mash
+      group.id.should eq '1'
+      group.title.should eq 'Goodreads Feedback'
+      group.access.should eq 'public'
+      group.location.should eq ''
+      group.category.should eq 'Business'
+      group.subcategory.should eq 'Companies'
+      group.group_users_count.should eq '10335'
+    end
+  end
+
+  describe '#group_list' do
+    before { stub_with_key_get('/group/list', {:id => '1', :sort => 'my_activity'}, 'group_list.xml') }
+
+    it "returns groups a given user is a member of" do
+      group_list = client.group_list('1')
+
+      group_list.should be_a Hashie::Mash
+      group_list.total.should eq '107'
+      group_list.group.count.should eq 50
+      group_list.group[0].id.should eq '1'
+      group_list.group[0].title.should eq 'Goodreads Feedback'
+      group_list.group[1].id.should eq '220'
+      group_list.group[2].users_count.should eq '530'
+    end
+  end
+end

data/spec/goodreads_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe 'Goodreads' do
+  describe '.new' do
+    it 'returns a new client instance' do
+      Goodreads.new.should be_a Goodreads::Client
+    end
+  end
+
+  describe '.configure' do
+    it 'sets a global configuration options' do
+      r = Goodreads.configure(:api_key => 'FOO', :api_secret => 'BAR')
+      r.should be_a Hash
+      r.should have_key(:api_key)
+      r.should have_key(:api_secret)
+      r[:api_key].should eql('FOO')
+      r[:api_secret].should eql('BAR')
+    end
+
+    it 'raises ConfigurationError on invalid config parameter' do
+      proc { Goodreads.configure(nil) }.
+        should raise_error(ArgumentError, "Options hash required.")
+
+      proc { Goodreads.configure('foo') }.
+        should raise_error ArgumentError, "Options hash required."
+    end
+  end
+
+  describe '.configuration' do
+    before do
+      Goodreads.configure(:api_key => 'FOO', :api_secret => 'BAR')
+    end
+
+    it 'returns global configuration options' do
+      r = Goodreads.configuration
+      r.should be_a Hash
+      r.should have_key(:api_key)
+      r.should have_key(:api_secret)
+      r[:api_key].should eql('FOO')
+      r[:api_secret].should eql('BAR')
+    end
+  end
+
+  describe '.reset_configuration' do
+    before do
+      Goodreads.configure(:api_key => 'FOO', :api_secret => 'BAR')
+    end
+
+    it 'resets global configuration options' do
+      Goodreads.reset_configuration
+      Goodreads.configuration.should eql({})
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,38 @@
+$:.unshift File.expand_path("../..", __FILE__)
+
+require 'simplecov'
+SimpleCov.start do
+  add_group 'Goodreads', 'lib/goodreads'
+end
+
+require 'goodreads'
+require 'webmock'
+require 'webmock/rspec'
+
+def stub_get(path, params, fixture_name)
+  params[:format] = 'xml'
+  stub_request(:get, api_url(path)).
+    with(:query => params).
+    to_return(
+      :status => 200,
+      :body => fixture(fixture_name)
+    )
+end
+
+def stub_with_key_get(path, params, fixture_name)
+  params[:key] = 'SECRET_KEY'
+  stub_get(path, params, fixture_name)
+end
+
+def fixture_path(file=nil)
+  path = File.expand_path("../fixtures", __FILE__)
+  file.nil? ? path : File.join(path, file)
+end
+
+def fixture(file)
+  File.read(fixture_path(file))
+end
+
+def api_url(path)
+  "#{Goodreads::Request::API_URL}#{path}"
+end

metadata

@@ -0,0 +1,212 @@
+--- !ruby/object:Gem::Specification
+name: goodreads_17up
+version: !ruby/object:Gem::Version
+  version: 0.2.1
+platform: ruby
+authors:
+- Dan Sosedoff
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.12'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.6'
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: hashie
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: i18n
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: oauth
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.4'
+description: Simple wrapper for the Goodreads API
+email:
+- dan.sosedoff@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- README.md
+- Rakefile
+- examples/oauth.md
+- goodreads.gemspec
+- lib/goodreads.rb
+- lib/goodreads/client.rb
+- lib/goodreads/client/authorized.rb
+- lib/goodreads/client/authors.rb
+- lib/goodreads/client/books.rb
+- lib/goodreads/client/friends.rb
+- lib/goodreads/client/groups.rb
+- lib/goodreads/client/reviews.rb
+- lib/goodreads/client/shelves.rb
+- lib/goodreads/client/users.rb
+- lib/goodreads/errors.rb
+- lib/goodreads/request.rb
+- lib/goodreads/version.rb
+- spec/authentication_spec.rb
+- spec/client_spec.rb
+- spec/goodreads_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/sosedoff/goodreads
+licenses: []
+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.0.0
+signing_key: 
+specification_version: 4
+summary: Goodreads API wrapper
+test_files:
+- spec/authentication_spec.rb
+- spec/client_spec.rb
+- spec/goodreads_spec.rb
+- spec/spec_helper.rb