shared_book 0.1.0

data/History.txt

@@ -0,0 +1,3 @@
+=== 0.0.1 2010-11-08
+
+ * Initial release

data/Manifest.txt

@@ -0,0 +1,9 @@
+History.txt
+Manifest.txt
+README.rdoc
+Rakefile
+lib/shared_book.rb
+spec/lib/shared_book_spec.rb
+spec/spec.opts
+spec/spec_helper.rb
+tasks/rspec.rake

data/README.rdoc

@@ -0,0 +1,100 @@
+= shared_book
+
+* http://github.com/xunker/shared_book
+
+== DESCRIPTION:
+
+A Ruby Gem to connect to the SharedBook.com publishing API.
+
+This version provides 1:1 method call structure to the SharedBook rest-like API.
+
+== SYNOPSIS:
+
+  s = SharedBook.new(
+    :product_api_key => "xxxx-xxxx-xxxx-xxxx-xxxx-xxxx-x",
+    :product_secret_word => "xxxx-xxxx-xxxx-xxxx-xxxx-xxxx-x",
+    :auth_token => "xxxxx_xxx",
+    :get_session_token => true
+  )
+  
+  s.bmscreate_init('test book',
+    [{:chapterTitle => 'chapter 1', :chapterText => 'text'}, {:chapterTitle => 'chapter 2', :chapterText => 'text'}]
+  )
+  
+  s.bmscreate_publish
+  
+  s.bms_addComment(:comment_title => 'comment', :comment_text => 'text', :owner_name => 'George')
+
+  s.bms_addPhoto_by_url(:file_url => 'http://www.example.com/images/logo.png', :owner_name => 'Geroge')
+  s.bms_addPhoto_by_handle(:file_name => "../images/angry_squirrel.jpg", :file_mime => "image/jpeg", :owner_name => 'Gerogee')
+  s.bms_setFrontCoverPhoto(:file_name => "../images/angry_squirrel.jpg", :file_mime => "image/jpeg", :owner_name => 'Gerogee')
+  s.bms_setBackCoverPhoto(:file_name => "../images/angry_squirrel.jpg", :file_mime => "image/jpeg", :owner_name => 'Gerogee')
+
+  s.bms_publish
+  s.bookcreate_init
+  s.bookcreate_setDedication(:dedication_text => 'Dedicated!')
+  s.bookcreate_publish
+  s.book_preview
+
+== USAGE:
+
+Before calling SharedBook.new you will need to send you web client to the URL provided by SharedBook.auth_login_url.  This URL will return the user to your SharedBook.com return URL and it will have a unique auth token appended to the query string.  You must retrieve that token and pass it in to SharedBook.new as :auth_token.
+
+For testing you can call SharedBook.new with an :auth_token value of 'auto' which will automatically get this token for you but the preview URL given my book_preview will be inaccessible.  :auth_token => 'auto' should never, ever, ever be used for production purposes.
+
+During a real usage scenario, the order of operations should follow roughtly:
+  
+  s = SharedBook.new
+  s.bmscreate_init
+  s.bmscreate_publish
+  s.bms_addComment
+  s.bms_addPhoto_by_url
+  s.bms_addPhoto_by_handle
+  s.bms_setFrontCoverPhoto
+  s.bms_setBackCoverPhoto
+  s.bms_publish
+  s.bookcreate_init
+  s.bookcreate_setDedication
+  s.bookcreate_publish
+  s.book_preview
+  
+== REQUIREMENTS:
+
+This library is useless unless you have an account at SharedBook.com.
+
+You will need to know your the API key and secret word for your product
+and pass them in to the constructor.
+
+== INSTALL:
+
+gem install shared_book
+
+== TODO:
+
+* Add the ability to post a picture using data from a string, not just a URL or filename.
+* Add a more ruby-like method for creating a new SharedBook object.
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2010 Matthew Nielsen
+
+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,19 @@
+require 'rubygems'
+gem 'hoe', '>= 2.1.0'
+gem 'multipart-post', '>= 1.0.1'
+require 'hoe'
+require 'fileutils'
+require './lib/shared_book'
+
+VERSION = "0.1.0"
+
+Hoe.plugin :newgem
+
+$hoe = Hoe.spec 'shared_book' do
+  self.developer 'Matthew Nielsen', 'xunker@pyxidis.org'
+end
+
+require 'newgem/tasks'
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+task :default => :spec

data/lib/shared_book.rb

@@ -0,0 +1,280 @@
+# order of calls
+#
+# s = SharedBook.new { ... }
+# s.get_session_token .. or .. pass :get_session_token => true to .new
+# s.bmscreate_init('test book', {:chapterTitle => 'chapter 1', :chapterText => 'text'})
+#   ... or ...
+# s.bmscreate_init('test book', [{:chapterTitle => 'chapter 1', :chapterText => 'text'}, {:chapterTitle => 'chapter 2', :chapterText => 'text'}])
+# s.bmscreate_publish
+# s.bms_addComment { ... }
+# s.bms_addPhoto_by_url { ... }
+# s.bms_addPhoto_by_handle { ... }
+# s.bms_setFrontCoverPhoto { ... }
+# s.bms_setBackCoverPhoto { ... }
+# s.bms_publish
+# s.bookcreate_init
+# s.bookcreate_setDedication { ... }
+# s.bookcreate_publish
+# s.book_preview
+
+class SharedBookError < StandardError; end
+class MissingCredentialError < SharedBookError; end
+class MissingAuthTokenError < MissingCredentialError; def to_s; "Please supply auth_token given from '/auth/login'"; end; end
+class MissingSessionTokenError < MissingCredentialError; end
+class MissingProductApiKeyError < MissingCredentialError; def to_s; "Please supply product_api_key"; end; end
+class MissingProductSecretWordError < MissingCredentialError; def to_s; "Please supply product_secret_word"; end; end
+class ResponseError < SharedBookError; end
+
+class SharedBook
+  require 'rubygems'
+  require 'kconv'
+  require 'net/http'
+  require 'net/http/post/multipart'
+  require 'digest/md5'
+  require 'uri'
+  
+  URL = "http://api.sharedbook.com/v0.6"
+  DEFAULT_THEME = 'vanilla'
+  
+  attr_reader :product_api_key, :session_token, :auth_token, :product_secret_word, :bms_id, :book_id, :comment_ids, :photo_ids, :front_cover_photo_id, :back_cover_photo_id, :book_url
+  attr_accessor :book_title, :articles 
+  
+  def initialize(opts = {})
+    if opts[:product_api_key]
+      @product_api_key = opts[:product_api_key]
+    else
+      raise MissingProductApiKeyError
+    end
+    
+    if opts[:product_secret_word]
+      @product_secret_word = opts[:product_secret_word]
+    else
+      raise MissingProductSecretWordError
+    end
+    
+    if opts[:auth_token]
+      @auth_token = if opts[:auth_token] == 'auto'
+        get_new_auth_token
+      else
+        opts[:auth_token]
+      end
+    else
+      raise MissingAuthTokenError
+    end
+  
+    if opts[:session_token]
+      @session_token = opts[:session_token]
+    else
+      @session_token = auth_getSessionToken if opts[:get_session_token]
+    end
+
+  end
+  
+  def self.auth_login_url
+    "#{URL}/auth/login"
+  end
+    
+  def auth_getSessionToken
+    return session_token if session_token # you can't call the service twice with the same auth_token
+    response = get_url("#{URL}/auth/getSessionToken", :apiKey => @product_api_key, :authToken => @auth_token)
+    parse_response(response, /\<sessionToken\>(.*)\<\/sessionToken\>/)
+  end
+  
+  def session_token
+    @session_token
+  end
+    
+  def bmscreate_init(book_title=@book_title, articles=@articles, theme=DEFAULT_THEME)
+    article_hash = if articles.class == Array
+      hh = {}
+      articles.each_with_index do |article, i|
+        hh["chapterTitle#{i+1}".to_sym] = article[:chapterTitle]
+        hh["chapterText#{i+1}".to_sym] = article[:chapterText]
+      end
+      hh
+    else
+      articles # expected to be hash with :chapterTitle and :chapterText
+    end
+    response = post_url("#{URL}/bmscreate/init", {:bookTitle => book_title}.merge(article_hash))
+    @bms_id = parse_response(response, /\<bms id=\"(\d+)\"/)
+  end
+  
+  def bmscreate_publish(bms_id = @bms_id) 
+    response = post_url("#{URL}/bmscreate/publish", {:bmsId => bms_id})
+    parse_response(response, /status=\"ok\"/) { true }
+  end
+  
+  def bms_addComment(opts = {})
+    required = {:bmsId => opts[:bms_id] || @bms_id, :commentTitle => opts[:comment_title], :commentText => opts[:comment_text],
+    :chapterNumber => opts[:chapter_number].to_s, :ownerName => opts[:owner_name]}
+    optional = {:time => opts[:time], :commentId => opts[:comment_id]}.reject{|k,v| v.nil?}
+    
+    response = post_url("#{URL}/bms/addComment", required.merge(optional))
+    
+    parse_response(response, /comment id=\"(.*)\"/) do |match|
+      @comment_ids ||= []
+      @comment_ids << match[1]
+      @comment_ids.last
+    end
+  end
+  
+  def bms_addPhoto_by_url(opts = {})
+    required = {:bmsId => opts[:bms_id] || @bms_id, :url => opts[:file_url], :ownerName => opts[:owner_name]}
+    optional = {:time => opts[:time], :caption => opts[:caption], :photoId => opts[:photo_id], :photoOrdinal => opts[:photo_ordinal]}.reject{|k,v| v.nil?}
+    
+    response = post_url("#{URL}/bms/addPhoto", required.merge(optional))
+    parse_response(response, /\<photo id=\"(.*)\"/) do |match|
+      @photo_ids ||= []
+      @photo_ids << match[1]
+      @photo_ids.last
+    end
+  end
+  
+  def bms_addPhoto_by_handle(opts = {})
+    parse_response(post_photo_data("#{URL}/bms/addPhoto", opts), /\<photo id=\"(.*)\"/) do |match|
+      @photo_ids ||= []
+      @photo_ids << match[1]
+      @photo_ids.last
+    end
+  end
+  
+  def bms_setFrontCoverPhoto(opts = {})
+    @front_cover_photo_id = set_cover_photo(:front, opts)
+  end
+  
+  def bms_setBackCoverPhoto(opts = {})
+    @back_cover_photo_id = set_cover_photo(:back, opts)
+  end
+    
+  def bms_publish(bms_id = @bms_id) 
+    response = post_url("#{URL}/bms/publish", {:bmsId => bms_id})
+    parse_response(response, /status=\"ok\"/) { true }
+  end
+  
+  def bookcreate_init(bms_id = @bms_id) 
+    response = post_url("#{URL}/bookcreate/init", {:bmsId => bms_id})    
+    parse_response(response, /status=\"ok\"/) { true }
+  end
+  
+  def bookcreate_setDedication(opts = {})
+    response = post_url("#{URL}/bookcreate/setDedication", {:bmsId => opts[:bms_id] || @bms_id, :dedicationText => opts[:dedication_text]})
+    parse_response(response, /status=\"ok\"/) { true }    
+  end
+  
+  def bookcreate_publish(bms_id = @bms_id) 
+    response = post_url("#{URL}/bookcreate/publish", {:bmsId => bms_id})
+    @book_id = parse_response(response, /\<book id=\"(\d+)\" \/\>/)
+  end
+  
+  def book_preview(bms_id = @bms_id, book_id = @book_id)
+    query = {
+        :bmsId => bms_id.to_s, :bookId => book_id.to_s, :redirect => 'false', :apiKey => @product_api_key,
+        :sessionToken => session_token, :authToken => @auth_token
+    }
+    query.merge!(generate_signature(query))
+    response = get_url("#{URL}/book/preview", query)
+    @book_url = parse_response(response, /\<url\>(.*)\<\/url\>/).gsub(/&amp\;/, "&")
+  end
+
+private
+
+  def parse_response(response, pattern, &block)
+    if match = response.match(pattern)
+      if block_given?
+        yield match
+      else
+        match[1]
+      end
+    else
+      raise ResponseError, response
+    end
+  end
+    
+  def get_url(path, query = {})
+    url = URI.parse("#{path}?#{query_params(query)}")
+
+    req = Net::HTTP::Get.new([url.path, url.query].join('?'))
+    res = Net::HTTP.start(url.host, url.port) {|http|
+      http.request(req)
+    }
+    res.body
+  end
+  
+  def post_url(path, query = {})
+    query.merge!({:apiKey => @product_api_key, :sessionToken => session_token, :authToken => @auth_token})
+    query.merge!(generate_signature(query)) # must be added last
+    
+    res = Net::HTTP.post_form(URI.parse(path), query)
+
+    case res
+    when Net::HTTPSuccess, Net::HTTPRedirection
+      res.body
+    else
+      raise ResponseError, res.error! #res.error!?
+    end
+    
+  end
+  
+  def post_url_file(path, query = {})
+    query.merge!({:apiKey => @product_api_key, :sessionToken => session_token, :authToken => @auth_token})
+    query.merge!(generate_signature(query)) # must be added last
+
+    url = URI.parse(path)
+    req = Net::HTTP::Post::Multipart.new url.path, query
+    res = Net::HTTP.start(url.host, url.port) do |http|
+      http.request(req)
+    end
+
+    case res
+    when Net::HTTPSuccess, Net::HTTPRedirection
+      res.body
+    else
+      raise ResponseError, res.error! #res.error!?
+    end
+    
+  end
+  
+  def query_params(query={})
+    query.map{|k,v| [k, v].join('=')}.join('&')
+  end
+  
+  def generate_signature(query)
+    str=""
+    query.keys.sort{|a,b| a.to_s <=> b.to_s}.each do |key|
+      str << key.to_s+query[key] unless query[key].class == File
+    end
+    
+    {:signature => Digest::MD5.hexdigest(@product_secret_word.toutf8+str.toutf8)}
+  end
+  
+  def get_new_auth_token
+    if ENV['RAILS_ENV']
+      puts "*** YOU SHOULD ONLY USE THIS IN DEVELOPMENT MODE ***" unless ENV['RAILS_ENV'] == 'development'
+    end
+    
+    res = Net::HTTP.post_form(URI.parse(SharedBook.auth_login_url), {:apiKey => @product_api_key})
+
+    case res
+    when Net::HTTPSuccess, Net::HTTPRedirection
+      res.body.match(/\?authToken=(.*)\"\>/)[1]
+    else
+      raise ResponseError, res.error! #res.error!?
+    end  
+  end
+  
+  def set_cover_photo(cover, opts={})
+    raise "only Front or Back cover" unless %w[front back].include?(cover.to_s)
+    
+    parse_response(post_photo_data("#{URL}/bms/set#{cover.to_s.capitalize}CoverPhoto", opts), /\<photo id=\"(.*)\"/)
+  end
+  
+  def post_photo_data(url, opts={})
+    required = {:bmsId => opts[:bms_id] || @bms_id, :file_name => opts[:file_name], :file_mime => opts[:file_mime], :ownerName => opts[:owner_name]}
+    optional = {:time => opts[:time], :caption => opts[:caption], :photoId => opts[:photo_id], :photoOrdinal => opts[:photo_ordinal]}.reject{|k,v| v.nil?}
+    
+    File.open(opts[:file_name]) do |file_upload|
+      post_url_file(url, required.merge(optional).merge({"photo" => UploadIO.new(file_upload, opts[:file_mime], opts[:file_name])}))
+    end
+  end
+  
+end

data/spec/lib/shared_book_spec.rb

@@ -0,0 +1,398 @@
+require 'spec_helper'
+
+def gem_root
+  File.dirname(__FILE__) + '/../..'
+end
+
+def post_should_get_response_error(method, arg=nil)
+  @sharedbook.should_receive(:post_url).and_return(@bad_return)
+  method_should_get_response_error(method, arg)
+end
+
+def get_should_get_response_error(method, arg=nil)
+  @sharedbook.should_receive(:get_url).and_return(@bad_return)
+  method_should_get_response_error(method, arg)
+end
+
+def method_should_get_response_error(method, arg=nil)
+  lambda { arg ? @sharedbook.send(method, arg) : @sharedbook.send(method) }.should raise_error(ResponseError)
+end
+
+describe SharedBook do
+  before(:each) do
+    @valid = {:product_api_key => 'x', :product_secret_word => 'x', :auth_token => 'x', :session_token => 'aabbcc'}
+    @sharedbook = SharedBook.new(@valid)
+    @bad_return = "<p>B0RKEN!</p>"
+  end
+    
+  describe '.new' do
+    it 'should require product_api_key, product_secret_word and auth_token' do
+      lambda { SharedBook.new(:product_api_key => 'x', :product_secret_word => 'x') }.should raise_error(MissingAuthTokenError)
+      
+      lambda { SharedBook.new(:product_api_key => 'x', :auth_token => 'x') }.should raise_error(MissingProductSecretWordError)
+      
+      lambda { SharedBook.new(:auth_token => 'x', :product_secret_word => 'x') }.should raise_error(MissingProductApiKeyError)
+    end    
+  end
+  
+  describe '.auth_login_url' do
+    it 'should return the login url that the web user should be sent to' do
+      SharedBook.auth_login_url.should == "#{SharedBook::URL}/auth/login"
+    end
+  end
+  
+  describe '#auth_getSessionToken' do
+    before(:each) do
+      @sharedbook = SharedBook.new(@valid.merge(:session_token => nil))
+    end
+    
+    it 'should get the session token for a given auth_token' do
+      # expect
+      @sharedbook.should_receive(:get_url).with("#{SharedBook::URL}/auth/getSessionToken", {:apiKey=>"x", :authToken=>"x"}).and_return(
+        "<auth.getSessionToken status=\"ok\">\n\t<sessionToken>a1b2c3</sessionToken>\n</auth.getSessionToken>"
+      )
+      
+      @sharedbook.auth_getSessionToken.should == "a1b2c3"
+    end
+    
+    it "should return the already-known session ID if we already know it" do
+      # given
+      @sharedbook.stub(:session_token).and_return('xyz')
+      
+      # expect
+      @sharedbook.should_not_receive(:get_url)
+      
+      # when
+      @sharedbook.auth_getSessionToken.should == 'xyz'
+    end
+    
+    it "should raise ResponseError if the response cannot be parsed" do
+      # expect
+      get_should_get_response_error(:auth_getSessionToken)
+    end
+  end
+  
+  describe '#session_token' do
+    it "should return the current session token" do
+      # given
+      sharedbook = SharedBook.new(@valid.merge(:session_token => nil))
+      # expect
+      sharedbook.session_token.should be_nil
+      
+      # given
+      sharedbook = SharedBook.new(@valid.merge(:session_token => 'abc'))
+      # expect
+      sharedbook.session_token.should == 'abc'
+    end
+  end
+  
+  describe '#bmscreate_init' do
+    before(:all) do
+      @return = "<bmscreate.init status=\"ok\">\n\t<bms id=\"11235\" />\n</bmscreate.init>"
+    end
+    context 'with one article' do
+      it 'should post to the init url and return a bms_id' do
+        # expect
+        @sharedbook.should_receive(:post_url).with(
+          "#{SharedBook::URL}/bmscreate/init",
+          {:bookTitle=>"book title", :chapterTitle=>"chapter 1", :chapterText=>"text"}
+        ).and_return(@return)
+      
+        # given
+        @sharedbook.bmscreate_init("book title", {:chapterTitle => 'chapter 1', :chapterText => 'text'}).should == '11235'
+        @sharedbook.bms_id.should == "11235"
+      end
+    end
+    context 'with more than one article' do
+      it 'should post to the init url and return a bms_id' do
+        # expect
+        @sharedbook.should_receive(:post_url).with(
+          "#{SharedBook::URL}/bmscreate/init",
+          {:chapterText1=>"text", :bookTitle=>"book title", :chapterTitle2=>"chapter 2", :chapterText2=>"text", :chapterTitle1=>"chapter 1"}
+        ).and_return(@return)
+      
+        # given
+        @sharedbook.bmscreate_init("book title", [
+          {:chapterTitle => 'chapter 1', :chapterText => 'text'}, {:chapterTitle => 'chapter 2', :chapterText => 'text'}
+        ]).should == '11235'
+      end
+    end
+    
+    it 'should raise ResponseError if the return cannot be parsed' do
+      # expect
+      @sharedbook.should_receive(:post_url).and_return(@bad_return)
+      
+      # given
+      lambda {
+        @sharedbook.bmscreate_init("book title", {:chapterTitle => 'chapter 1', :chapterText => 'text'}).should == '11235'
+      }.should raise_error(ResponseError)
+    end    
+  end
+  
+  describe '#bmscreate_publish' do
+    it 'should post the the publish url' do
+      # expect
+      @sharedbook.should_receive(:post_url).with(
+        "#{SharedBook::URL}/bmscreate/publish",
+        {:bmsId=>123}
+      ).and_return("<publish status=\"ok\" />")
+      
+      # given
+      @sharedbook.bmscreate_publish(123).should be_true
+    end
+    
+    it 'should raise ResponseError if the return cannot be parsed' do
+      # expect
+      post_should_get_response_error(:bmscreate_publish, 123)
+    end
+  end
+  
+  describe '#bms_addComment' do
+    it 'should post the add comment url and return a comment id' do
+      # expect
+      @sharedbook.should_receive(:post_url).with(
+        "#{SharedBook::URL}/bms/addComment",
+        {:ownerName=>"Joe", :commentTitle=>"title", :bmsId=>123, :commentText=>"text", :chapterNumber=>"1"}
+      ).and_return(
+        "<bms.addComment status=\"ok\">\n\t<comment id=\"x1y1z1\" />\n</bms.addComment>"
+      )
+      
+      # given
+      @sharedbook.bms_addComment({
+        :bms_id => 123, :comment_title => 'title', :comment_text => 'text', :chapter_number => 1, :owner_name => 'Joe'
+      }).should == 'x1y1z1'
+      @sharedbook.comment_ids.should == ["x1y1z1"]
+    end
+    it 'should raise ResponseError if the return cannot be parsed' do
+      # expect
+      @sharedbook.should_receive(:post_url).and_return(@bad_return)
+      
+      # given
+      lambda { @sharedbook.bms_addComment({
+        :bms_id => 123, :comment_title => 'title', :comment_text => 'text', :chapter_number => 1, :owner_name => 'Joe'
+      }) }.should raise_error(ResponseError)
+    end
+  end
+  
+  describe '#bms_addPhoto_by_url' do
+    before(:each) do
+      @image = "http://examp.le/x.jpg"
+      @valid_post = {:bms_id => 123, :file_url => @image, :chapter_number => 1, :owner_name => 'Joe'}
+    end
+    
+    it 'should post to the add photo url with the url of the photo to add and return a photo id' do
+      # expect
+      @sharedbook.should_receive(:post_url).with(
+        "#{SharedBook::URL}/bms/addPhoto",
+        {:ownerName=>"Joe", :bmsId=>123, :url => @image}
+      ).and_return(
+        "<bms.addPhoto status=\"ok\">\n\t<photo id=\"q1w2e3\" />\n</bms.addPhoto>"
+      )
+      
+      # given
+      @sharedbook.bms_addPhoto_by_url(@valid_post).should == 'q1w2e3'
+      @sharedbook.photo_ids.should == ["q1w2e3"]
+    end
+    it 'should raise ResponseError if the return cannot be parsed' do
+      # expect
+      @sharedbook.should_receive(:post_url).and_return(@bad_return)
+      
+      # given
+      lambda { @sharedbook.bms_addPhoto_by_url(@valid_post) }.should raise_error(ResponseError)
+    end    
+  end
+  
+  describe '#bms_addPhoto_by_handle' do
+    before(:each) do
+      @image = gem_root+"/spec/images/angry_squirrel.jpg"
+      @valid_post = {:bms_id => 123, :file_name => @image, :file_mime => "image/jpeg", :chapter_number => 1, :owner_name => 'Joe'}
+      UploadIO.stub!(:new)
+    end
+    
+    it 'should post to the add photo url with the data of the photo to add and return a photo id' do
+      # expect
+      @sharedbook.should_receive(:post_url_file).with(
+        "#{SharedBook::URL}/bms/addPhoto",
+        {"photo"=>nil, :ownerName=>"Joe", :file_name=>@image, :file_mime=>"image/jpeg", :bmsId=>123}
+      ).and_return(
+        "<bms.addPhoto status=\"ok\">\n\t<photo id=\"q1w2e3\" />\n</bms.addPhoto>"
+      )
+      
+      # given
+      @sharedbook.bms_addPhoto_by_handle(@valid_post).should == 'q1w2e3'
+      @sharedbook.photo_ids.should == ["q1w2e3"]
+    end
+    it 'should raise ResponseError if the return cannot be parsed' do
+      # expect
+      @sharedbook.should_receive(:post_url_file).and_return(@bad_return)
+      
+      # given
+      lambda { @sharedbook.bms_addPhoto_by_handle(@valid_post) }.should raise_error(ResponseError)
+    end    
+  end
+
+  describe '#bms_setFrontCoverPhoto' do
+    before(:each) do
+      @image = gem_root+"/spec/images/angry_squirrel.jpg"
+      @id = "q1w2e3"
+      @valid_post = {:bms_id => 123, :file_name => @image, :file_mime => "image/jpeg", :chapter_number => 1, :owner_name => 'Joe'}
+      UploadIO.stub!(:new)
+    end
+    
+    it 'should post the image data to the url for setting the front cover and return an id' do
+      # expect
+      @sharedbook.should_receive(:post_url_file).with(
+        "#{SharedBook::URL}/bms/setFrontCoverPhoto",
+        {"photo"=>nil, :ownerName=>"Joe", :file_name=>@image, :file_mime=>"image/jpeg", :bmsId=>123}
+      ).and_return(
+        "<bms.addPhoto status=\"ok\">\n\t<photo id=\"#{@id}\" />\n</bms.addPhoto>"
+      )
+      
+      # given
+      @sharedbook.bms_setFrontCoverPhoto(@valid_post).should == @id
+      @sharedbook.front_cover_photo_id.should == @id
+    end
+    it 'should raise ResponseError if the return cannot be parsed' do
+      # expect
+      @sharedbook.should_receive(:post_url_file).and_return(@bad_return)
+      
+      # given
+      lambda { @sharedbook.bms_setFrontCoverPhoto(@valid_post) }.should raise_error(ResponseError)
+    end    
+  end
+  
+  describe '#bms_setBackCoverPhoto' do
+    before(:each) do
+      @image = gem_root+"/spec/images/angry_squirrel.jpg"
+      @id = "q1w2e3"
+      @valid_post = {:bms_id => 123, :file_name => @image, :file_mime => "image/jpeg", :chapter_number => 1, :owner_name => 'Joe'}
+      UploadIO.stub!(:new)
+    end
+    
+    it 'should post the image data to the url for setting the front cover and return an id' do
+      # expect
+      @sharedbook.should_receive(:post_url_file).with(
+        "#{SharedBook::URL}/bms/setBackCoverPhoto",
+        {"photo"=>nil, :ownerName=>"Joe", :file_name=>@image, :file_mime=>"image/jpeg", :bmsId=>123}
+      ).and_return(
+        "<bms.addPhoto status=\"ok\">\n\t<photo id=\"#{@id}\" />\n</bms.addPhoto>"
+      )
+      
+      # given
+      @sharedbook.bms_setBackCoverPhoto(@valid_post).should == @id
+      @sharedbook.back_cover_photo_id.should == @id
+    end
+    it 'should raise ResponseError if the return cannot be parsed' do
+      # expect
+      @sharedbook.should_receive(:post_url_file).and_return(@bad_return)
+      
+      # given
+      lambda { @sharedbook.bms_setBackCoverPhoto(@valid_post) }.should raise_error(ResponseError)
+    end    
+  end
+  
+  describe '#bms_publish' do
+    it 'should post the the publish url' do
+      # expect
+      @sharedbook.should_receive(:post_url).with(
+        "#{SharedBook::URL}/bms/publish",
+        {:bmsId=>123}
+      ).and_return("<bms.publish status=\"ok\" />")
+      
+      # given
+      @sharedbook.bms_publish(123).should be_true
+    end
+    
+    it 'should raise ResponseError if the return cannot be parsed' do
+      # expect
+      post_should_get_response_error(:bms_publish, 123)
+    end
+  end
+  
+  describe '#bookcreate_init' do
+    it 'should post the the publish url' do
+      # expect
+      @sharedbook.should_receive(:post_url).with(
+        "#{SharedBook::URL}/bookcreate/init",
+        {:bmsId=>123}
+      ).and_return("<bookcreate.init status=\"ok\" />")
+      
+      # given
+      @sharedbook.bookcreate_init(123).should be_true
+    end
+    
+    it 'should raise ResponseError if the return cannot be parsed' do
+      # expect
+      post_should_get_response_error(:bookcreate_init, 123)
+    end
+  end
+
+  describe '#bookcreate_setDedication' do
+    it 'should post the the publish url' do
+      # expect
+      @sharedbook.should_receive(:post_url).with(
+        "#{SharedBook::URL}/bookcreate/setDedication",
+        {:dedicationText=>"Dedicated!", :bmsId=>123}
+      ).and_return("<bookcreate.setDedication status=\"ok\" />")
+      
+      # given
+      @sharedbook.bookcreate_setDedication({:bms_id => 123, :dedication_text => "Dedicated!"}).should be_true
+    end
+    
+    it 'should raise ResponseError if the return cannot be parsed' do
+      # expect
+      post_should_get_response_error(:bookcreate_setDedication, 123)
+    end
+  end  
+  
+  describe '#bookcreate_publish' do
+    it 'should post to the bookcreate publish url and return a book_id' do
+      # expect
+      @sharedbook.should_receive(:post_url).with(
+        "#{SharedBook::URL}/bookcreate/publish",
+        {:bmsId=>123}
+      ).and_return(
+        "<bookcreate.publish status=\"ok\" />\n\t<book id=\"54321\" />\n</bookcreate.init>"
+      )
+      
+      # given
+      @sharedbook.bookcreate_publish(123).should == "54321"
+      @sharedbook.book_id.should == "54321"
+    end
+    
+    it 'should raise ResponseError if the return cannot be parsed' do
+      # expect
+      post_should_get_response_error(:bookcreate_publish, 123)
+    end
+  end
+  
+  describe '#book_preview' do
+    before(:all) do
+      @preview_url = 'http://www.examp.le/12345'
+    end
+    it 'should post to the book preview url and return a preview url' do
+      # expect
+      @sharedbook.should_receive(:get_url).with(
+        "#{SharedBook::URL}/book/preview",
+        {:sessionToken=>"aabbcc", :apiKey=>"x", :authToken=>"x", :bookId=>"321", :redirect=>"false", :bmsId=>"123", :signature=>"5949fa652c1dba35111d978541ecb44e"}
+      ).and_return(
+        "<book.preview status=\"ok\">\n\t<url>#{@preview_url}</url></book.preview>"
+      )
+      
+      # given
+      @sharedbook.book_preview(123,321).should == @preview_url
+      @sharedbook.book_url.should == @preview_url
+      
+    end
+    
+    it 'should raise ResponseError if the return cannot be parsed' do
+      # expect
+      @sharedbook.should_receive(:get_url).and_return(@bad_return)
+      
+      # given
+      lambda { @sharedbook.book_preview(123,321) }.should raise_error(ResponseError)
+      
+    end
+  end
+   
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--colour

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+begin
+  require 'spec'
+rescue LoadError
+  require 'rubygems' unless ENV['NO_RUBYGEMS']
+  gem 'rspec'
+  require 'spec'
+end
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'shared_book'

data/tasks/rspec.rake

@@ -0,0 +1,21 @@
+begin
+  require 'spec'
+rescue LoadError
+  require 'rubygems' unless ENV['NO_RUBYGEMS']
+  require 'spec'
+end
+begin
+  require 'spec/rake/spectask'
+rescue LoadError
+  puts <<-EOS
+To use rspec for testing you must install rspec gem:
+    gem install rspec
+EOS
+  exit(0)
+end
+
+desc "Run the specs under spec/models"
+Spec::Rake::SpecTask.new do |t|
+  t.spec_opts = ['--options', "spec/spec.opts"]
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification 
+name: shared_book
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Matthew Nielsen
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-08 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rubyforge
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 2
+        - 0
+        - 4
+        version: 2.0.4
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 21
+        segments: 
+        - 2
+        - 6
+        - 1
+        version: 2.6.1
+  type: :development
+  version_requirements: *id002
+description: |-
+  A Ruby Gem to connect to the SharedBook.com publishing API.
+  
+  This version provides 1:1 method call structure to the SharedBook rest-like API.
+email: 
+- xunker@pyxidis.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.rdoc
+- Rakefile
+- lib/shared_book.rb
+- spec/lib/shared_book_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- tasks/rspec.rake
+has_rdoc: true
+homepage: http://github.com/xunker/shared_book
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: shared_book
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A Ruby Gem to connect to the SharedBook.com publishing API
+test_files: []
+