infomeme_client 0.1.1

data/lib/infomeme_client/functions/user.rb

@@ -0,0 +1,55 @@
+module InfomemeClient::Functions::User
+    attr_accessor :default_language, :default_currency
+
+    def register(email, username, password, firstname, lastname, optional_fields = {})
+	optional_fields.set(:language_code, optional_fields.key?(:language) ? optional_fields.delete(:language) : default_language) #language is mandatory
+	optional_fields.set(:currency_code, optional_fields.key?(:currency) ? optional_fields.delete(:currency) : default_currency) #currency is mandatory
+	handle_response :post, "/users/register", optional_fields.merge({:email => email, :username => username, :password => password, :firstname => firstname, :lastname => lastname}) do
+	    authorize_with_credentials username, password and return true
+	end
+    end
+
+    def user(user_id = nil)
+	return false if ! authorized? && user_id.nil?
+	extract_from_response :user, :get, "/users/#{user_id || verified_user}"
+    end
+
+    def update_settings(attribs = {})
+	return false unless authorized?
+	handle_response :put, "/users/#{verified_user}", attribs do
+	    refresh_settings and return true
+	end
+    end
+
+    def confirm(confirm_code)
+	return false unless authorized?
+	handle_response :put, "/users/#{verified_user}/confirm", {:confirm_code => confirm_code} do
+	    refresh_settings and return true
+	end
+    end
+
+    def confirmed?
+	authorized? && settings && settings.confirmed
+    end
+
+    def reset_password(user_id = nil)
+	return false if ! authorized? && user_id.nil?
+	handle_response :get, "/users/#{user_id || verified_user}/reset_password"
+    end
+
+    def new_password(new_password, user_id = nil, confirm_code = "")
+	return false if ! authorized? && user_id.nil?
+	handle_response :put, "/users/#{user_id || verified_user}/new_password", {:new_password => new_password}.merge(user_id.nil? ? {} : {:confirm_code => confirm_code})
+    end
+
+    private
+	attr_accessor :settings
+
+	def refresh_settings
+	    self.settings = nil
+	    return false unless authorized?
+	    response = get("/users/#{verified_user}")
+	    return false if response.error?
+	    self.settings = response.user
+	end
+end

data/lib/infomeme_client/functions/user_meme.rb

@@ -0,0 +1,94 @@
+module InfomemeClient::Functions::UserMeme
+    def library(options = {})
+	get_own_memes options
+    end
+
+    def published(options = {})
+	get_own_memes options, "published"
+    end
+
+    def inactive(options = {})
+	get_own_memes options, "inactive"
+    end
+
+    def incomplete(options = {})
+	get_own_memes options, "incomplete"
+    end
+
+    def can_publish?
+	authorized? && settings && settings.can_publish
+    end
+
+    def publish(meme_type, options = {})
+	return false unless can_publish?
+	handle_response :post, "/user/#{verified_user}/memes", options.merge({:meme_type => meme_type.respond_to?(:id) ? meme_type.id : meme_type}) do |resp|
+	    resp.meme_id unless resp.error?
+	end
+    end
+
+    def update_meme(meme_id, options = {})
+	meme_function meme_id, :put, nil, options
+    end
+
+    def delete_meme(meme_id)
+	meme_function meme_id, :delete
+    end
+
+    def confirm_meme(meme_id)
+	meme_function meme_id, :put, "confirm"
+    end
+
+    def activate_meme(meme_id)
+	meme_function meme_id, :put, "activate"
+    end
+
+    def deactivate_meme(meme_id)
+	meme_function meme_id, :put, "deactivate"
+    end
+
+    def upload_for_meme(meme_id, raw = false)
+	return false unless authorized?
+	handle_response :get, "/users/#{verified_user}/memes/#{meme_id}/upload_url" do |resp|
+	    (raw ? res.upload_url : finalize_get_url(resp.upload_url, generate_signature)) unless resp.error?
+	end
+    end
+
+    def upload(meme_id, file)
+	upload_url = upload_for_meme(meme_id, true)
+	if upload_url
+	    url = URI.parse(upload_url)
+	    req = Net::HTTP::Post::Multipart.new url.path, generate_signature.merge({:meme_id => meme_id, :file => file})
+	    resp = Net::HTTP.start(url.host, url.port) {|http| http.request(req)}
+	    resp == Net::HTTPSuccess
+	end
+    end
+
+    def rate(meme_id, rating)
+	return false unless authorized?
+	handle_response :post, "/users/#{verified_user}/memes/#{meme_id}/rates", {:rating => rating}
+    end
+
+    def comment(meme_id, comment)
+	return false unless authorized?
+	handle_response :post, "/users/#{verified_user}/memes/#{meme_id}/comments", {:comment => comment}
+    end
+
+    private
+	def generate_signature
+	    nonce = OAuth::Helper.generate_nonce
+	    timestamp = Time.now.to_i
+	    req_proxy = OAuth::RequestProxy.proxy("method" => "GET", "uri" => consumer.site, "parameters" => {"oauth_consumer_key" => consumer.key, "oauth_token" => token.token, "oauth_nonce" => nonce, "oauth_timestamp" => timestamp, "oauth_signature_method" => "HMAC-SHA1"})
+	    signature = req_proxy.sign({:consumer_secret => consumer.secret, :token_secret => token.secret})
+	    {:oauth_token => token.token, :oauth_nonce => nonce, :oauth_timestamp => timestamp, :oauth_signature => signature}
+	end
+
+	def get_own_memes(options = {}, cmd = nil, headers = {})
+	    return false unless authorized?
+	    get_memes("/users/#{verified_user}/memes" + (cmd.nil? ? "" : "/#{cmd}"), options, headers)
+	end
+
+	def meme_function(meme_id, method, cmd = nil, params = {}, headers = {})
+	    return false unless authorized?
+	    handle_response method, "/users/#{verified_user}/memes/#{meme_id}" + (cmd.nil? ? "" : "/#{cmd}"), params, headers
+	end
+end

data/lib/infomeme_client/functions/user_transaction.rb

@@ -0,0 +1,21 @@
+module InfomemeClient::Functions::UserTransaction
+    def transactions(options = {})
+	return false unless authorized?
+	extract_or_response :transactions, :get, "/users/#{verified_user}/transactions", options
+    end
+
+    def transaction(transaction_id)
+	return false unless authorized?
+	extract_from_response :transaction, :get, "/users/#{verified_user}/transactions/#{transaction_id}"
+    end
+
+    def invoices(options = {})
+	transactions = transactions(options)
+	transactions.collect {|tr| tr.invoice} if transactions
+    end
+
+    def invoice(transaction_id)
+	transaction = transaction(transaction_id)
+	transaction.invoice if transaction
+    end
+end

data/lib/infomeme_client/functions.rb

@@ -0,0 +1,16 @@
+module InfomemeClient::Functions
+    autoload :Meme, "infomeme_client/functions/meme"
+    autoload :User, "infomeme_client/functions/user"
+    autoload :UserMeme, "infomeme_client/functions/user_meme"
+    autoload :UserTransaction, "infomeme_client/functions/user_transaction"
+
+    include Meme
+    include User
+    include UserMeme
+    include UserTransaction
+
+    private
+	def get_memes(path, options = {}, headers = {})
+	    extract_or_response :memes, :get, path, options, headers
+	end
+end

data/lib/infomeme_client/meme_application.rb

@@ -0,0 +1,18 @@
+class InfomemeClient::MemeApplication
+    def initialize(options = {})
+	self.consumer = OAuth::Consumer.new(options[:api_key] || ::INFOMEME_API_KEY, options[:api_secret] || ::INFOMEME_API_SECRET, :site => options[:site] || ::INFOMEME_API_SITE)
+	self.token = OAuth::AccessToken.new(consumer)
+    end
+
+    def verify_access(meme_id, oauth_token, oauth_nonce, oauth_timestamp, oauth_signature)
+	handle_response :post, "/meme_app/verify_access", {:meme_id => meme_id, :verify_token => oauth_token, :verify_nonce => oauth_nonce, :verify_timestamp => oauth_timestamp, :verify_signature => oauth_signature}
+    end
+
+    def set_has_upload(meme_id, has_upload = true)
+	handle_response :put, "/meme_app/meme/#{meme_id}", {:has_upload => has_upload}
+    end
+
+    private
+	attr_accessor :consumer, :token
+	include InfomemeClient::Communication
+end

data/lib/infomeme_client/permissions.rb

@@ -0,0 +1,22 @@
+module InfomemeClient::Permissions
+    def all_permissions
+	handle_response :get, "/oauth/permissions" do |resp|
+	    resp.permissions unless resp.error?
+	end
+    end
+
+    def has_permission?(perm)
+	authorized? && permissions && permissions.include?(perm)
+    end
+
+    private
+	attr_accessor :permissions
+
+	def refresh_permissions
+	    self.permissions = nil
+	    return false unless authorized?
+	    response = get "/users/#{verified_user}/permissions"
+	    return false if response.error?
+	    self.permissions = response.permissions
+	end
+end

data/lib/infomeme_client/response.rb

@@ -0,0 +1,51 @@
+class InfomemeClient::Response < InfomemeClient::EntityHash
+    STATUS_FAILED = -1
+    STATUS_OK = 0
+    STATUS_ERROR = 1
+
+    ERRORS = {
+	"request_failed" => InfomemeClient::Error::RequestFailed,
+	"error" => InfomemeClient::Error,
+	"internal_error" => InfomemeClient::Error::InternalError,
+	"no_access" => InfomemeClient::Error::NoAccess,
+	"not_found" => InfomemeClient::Error::NotFound,
+    }.freeze
+
+    def initialize(response)
+	super(response.is_a?(Exception) ? {:status => STATUS_FAILED, :message => "Request failed.", :error_code => "request_failed", :errors => {:base => {response.class.name.to_sym => response.message}}} : response, true)
+	ERRORS.each do |key, val|
+	    instance_eval "def #{val.name.split('::').last.sub(/\b\w/) { $&.downcase }}Error?; error_code == #{key}; end"
+	end
+	freeze
+    end
+
+    def failed?
+	status == STATUS_FAILED
+    end
+
+    def error?
+	status != STATUS_OK
+    end
+
+    def raise_error(options = {})
+	return false unless error?
+	return false if options.key?(:only) && ! options[:only].include?(error_code)
+	return false if options.key?(:except) && options[:except].include?(error_code)
+	err = ERRORS.key?(error_code) ? ERRORS[error_code] : InfomemeClient::Error
+	raise err, [(respond_to?(:errors) ? errors.to_hash : nil), message]
+    end
+
+    def extract(key, *extra_args)
+	return nil unless @hsh.key?(key)
+	klass = case key
+	    when :comments then InfomemeClient::EntityHash::Comment
+	    when :meme, :memes then InfomemeClient::EntityHash::Meme
+	    when :meme_types then InfomemeClient::EntityHash::MemeType
+	    when :user then InfomemeClient::EntityHash::User
+	    when :transaction, :transactions then InfomemeClient::EntityHash::Transaction
+	    else InfomemeClient::EntityHash
+	end
+	stored = to_hash[key]
+	stored.is_a?(Array) ? stored.collect {|val| klass.new *[val, extra_args]} : klass.new(*[stored, extra_args])
+    end
+end

data/lib/infomeme_client.rb

@@ -0,0 +1,21 @@
+require "oauth"
+require "json"
+require "net/http/post/multipart"
+
+class InfomemeClient
+    require "infomeme_client/errors"
+
+    autoload :EntityHash, "infomeme_client/entity_hash"
+    autoload :Response, "infomeme_client/response"
+    autoload :Base, "infomeme_client/base"
+    autoload :Communication, "infomeme_client/communication"
+    autoload :Permissions, "infomeme_client/permissions"
+    autoload :Functions, "infomeme_client/functions"
+
+    autoload :MemeApplication, "infomeme_client/meme_application"
+
+    include Base
+    include Communication
+    include Permissions
+    include Functions
+end

data/test/fixtures/memes/comments.json

@@ -0,0 +1 @@
+{"status":0,"message":"Success.","comments":[{"comment":"test comment 1","user":{"username":"test_user"},"created_at":"2010-01-01 12:00:00"},{"comment":"test comment 2","user":{"username":"test_user"},"created_at":"2010-01-01 11:00:00"},{"comment":"test comment 3","user":{"username":"test_user"},"created_at":"2010-01-01 10:00:00"}],"pages":1,"count":3}

data/test/fixtures/memes/meme.json

@@ -0,0 +1 @@
+{"status":0,"message":"Success.","meme":{"id":1,"name":"test meme 1"}}

data/test/fixtures/memes/memes.json

@@ -0,0 +1 @@
+{"status":0,"message":"Success.","memes":[{"id":1,"name":"test meme 1"},{"id":2,"name":"test meme 2"},{"id":3,"name":"test meme 3"},{"id":4,"name":"test meme 4"}],"pages":1,"count":4}

data/test/fixtures/memes/types.json

@@ -0,0 +1 @@
+{"status":0,"message":"Success.","meme_types":[{"id":1,"name":"TEST","url":"http://test.url","summary":"test summary","description":"test description"}]}

data/test/fixtures/oauth/access_token.json

@@ -0,0 +1 @@
+{"status":0,"message":"Success.","access_token":{"token":"test_token","secret":"test_secret"}}

data/test/fixtures/oauth/authorize.json

@@ -0,0 +1 @@
+{"status":0,"message":"Success.","verifier":"test_verifier"}

data/test/fixtures/oauth/permissions.json

@@ -0,0 +1 @@
+{"status":0,"message":"Success.","permissions":[{"id":0,"name":"memes","description":"Meme functionality (comment, rate, publish, etc.)."},{"id":1,"name":"private_data","description":"Access to private data (firstname, lastname, cleared and pending balance)."},{"id":2,"name":"order","description":"Order functionality (order, transactions, invoices, etc.)."}]}

data/test/fixtures/oauth/request_token.json

@@ -0,0 +1 @@
+{"status":0,"message":"Success.","request_token":{"token":"test_token","secret":"test_secret"}}

data/test/fixtures/oauth/verify_access.json

@@ -0,0 +1 @@
+{"status":0,"message":"Success.","user_id":"test_user"}

data/test/fixtures/response/error.json

@@ -0,0 +1 @@
+{"status":1,"message":"Error.","error_code":"error","errors":{"test":{"test":"test error"}}}

data/test/fixtures/response/ok.json

@@ -0,0 +1 @@
+{"status":0,"message":"Success."}

data/test/fixtures/response/test.json

@@ -0,0 +1 @@
+{"status":0,"message":"Success.","test_message":"test message"}

data/test/fixtures/response/test_extract.json

@@ -0,0 +1 @@
+{"status":0,"message":"Success.","user":{"username":"test_user","email":"test@email.tld"}}

data/test/fixtures/users/memes.json

@@ -0,0 +1 @@
+{"status":0,"message":"Success.","memes":[{"id":1,"name":"test meme 1"},{"id":2,"name":"test meme 2"},{"id":3,"name":"test meme 3"},{"id":4,"name":"test meme 4"}],"pages":1,"count":4}

data/test/fixtures/users/permissions.json

@@ -0,0 +1 @@
+{"status":0,"message":"Success.","permissions":[0,1,2]}

data/test/fixtures/users/user.json

@@ -0,0 +1 @@
+{"status":0,"message":"Success.","user":{"username":"test_user","comments":3,"ratings":3,"language":"en","confirmed":true,"can_publish":true,"language":"en"}}

data/test/fixtures/users/user_public.json

@@ -0,0 +1 @@
+{"status":0,"message":"Success.","user":{"username":"test_user","comments":3,"ratings":3}}

data/test/helper.rb

@@ -0,0 +1,69 @@
+require "rubygems"
+require "test/unit"
+require "fakeweb"
+
+FakeWeb.allow_net_connect = false
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+require "infomeme_client"
+
+class Test::Unit::TestCase
+    def setup
+	@test_site = "https://test.api.site"
+	@test_api_key = "TEST_API_KEY"
+	@test_api_secret = "TEST_API_KEY"
+	@im_client = InfomemeClient.new :api_key => @test_api_key, :api_secret => @test_api_secret, :site => @test_site
+    end
+
+    private
+	def fake_request(method, url, options)
+	    FakeWeb.register_uri(method, infomeme_url(url), options)
+	end
+
+	def fake_authorize_requests
+	    fake_request(:get, "/oauth/verify_access", :body => fixture("oauth/verify_access"), :content_type => "application/json")
+	    fake_request(:get, "/users/test_user", :body => fixture("users/user"), :content_type => "application/json")
+	    fake_request(:get, "/users/test_user/permissions", :body => fixture("users/permissions"), :content_type => "application/json")
+	end
+
+	def authorize
+	    fake_authorize_requests
+	    assert_nothing_raised do
+		@im_client.authorize_with_token("test_token", "test_secret")
+	    end
+	    assert @im_client.authorized?
+	end
+
+	def fixture(filename)
+	    File.read(File.dirname(__FILE__) + "/fixtures/#{filename}.json")
+	end
+
+	def infomeme_url(url)
+	    url =~ /^http/ ? url : "#{@test_site}#{url}"
+	end
+
+	def check_paged(type, resp, options = {})
+	    assert_instance_of InfomemeClient::Response, resp
+	    assert_respond_to resp, type.to_sym
+	    assert_respond_to resp, :pages
+	    assert_respond_to resp, :count
+	    check_list(type, resp.extract(type.to_sym))
+	    assert_kind_of Integer, resp.pages
+	    assert_kind_of Integer, resp.count
+	end
+
+	def check_list(type, list)
+	    assert_instance_of Array, list
+	    type = type.to_s.sub(/s\z/, "").to_sym
+	    list.each do |elm|
+		check_eh(type, elm)
+	    end
+	end
+
+	def check_eh(type, obj)
+	    klass = InfomemeClient::EntityHash.const_get(type.to_s.split("_").map {|t| t.capitalize}.join.to_sym)
+	    assert_instance_of Class, klass, "couldn't determine class from #{type.inspect} (#{klass.inspect})"
+	    assert_instance_of klass, obj
+	end
+end

data/test/test_authorization.rb

@@ -0,0 +1,56 @@
+require "helper"
+
+class TestAuthorization < Test::Unit::TestCase
+    def test_request_authorization
+	fake_request(:get, "/oauth/request_token", :body => fixture("oauth/request_token"), :content_type => "application/json")
+	req_token = nil
+	assert_nothing_raised do
+	    req_token = @im_client.request_authorization
+	end
+	assert_kind_of InfomemeClient::EntityHash, req_token
+	assert_respond_to req_token, :token, req_token.inspect
+	assert_respond_to req_token, :secret, req_token.inspect
+	assert_equal "test_token", req_token.token, req_token.inspect
+	assert_equal "test_secret", req_token.secret, req_token.inspect
+    end
+
+    def test_authorize_with_verifier
+	fake_request(:get, "/oauth/access_token?oauth_verifier=test_verifier", :body => fixture("oauth/access_token"), :content_type => "application/json")
+	fake_authorize_requests
+	assert_nothing_raised do
+	    @im_client.authorize_with_verifier("test_token", "test_secret", "test_verifier")
+	end
+	check_authorized
+    end
+
+    def test_authorize_with_token
+	authorize
+	check_authorized
+    end
+
+    def test_authorize_with_credentials
+	fake_request(:get, "/oauth/request_token", :body => fixture("oauth/request_token"), :content_type => "application/json")
+	fake_request(:get, "/oauth/permissions", :body => fixture("oauth/permissions"), :content_type => "application/json")
+	fake_request(:put, "/oauth/authorize", :body => fixture("oauth/authorize"), :content_type => "application/json")
+	fake_request(:get, "/oauth/access_token?oauth_verifier=test_verifier", :body => fixture("oauth/access_token"), :content_type => "application/json")
+	fake_authorize_requests
+	assert_nothing_raised do
+	    @im_client.authorize_with_credentials("test_login", "test_password")
+	end
+	check_authorized
+	assert @im_client.has_permission?(0)
+	assert @im_client.has_permission?(1)
+	assert @im_client.has_permission?(2)
+    end
+
+    private
+	def check_authorized
+	    assert @im_client.authorized?
+	    assert @im_client.confirmed?
+	    assert @im_client.can_publish?
+	    cred = @im_client.credentials
+	    assert_equal "test_user", cred[:login]
+	    assert_equal "test_token", cred[:token]
+	    assert_equal "test_secret", cred[:secret]
+	end
+end