infomeme_client 0.2.1 → 0.2.3

data/lib/infomeme_client.rb

@@ -0,0 +1,22 @@
+require "oauth"
+require "json"
+require "net/http/post/multipart"
+require "mime/types"
+
+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/lib/infomeme_client/base.rb

@@ -0,0 +1,77 @@
+module InfomemeClient::Base
+    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.default_language = options[:language] || "en"
+	case
+	    when options.key?(:token) && options.key?(:secret) then authorize_with_token(options[:token], options[:secret])
+	    when options.key?(:login) && options.key?(:password) then authorize_with_credentials(options[:login], options[:password])
+	    else deauthorize
+	end
+    end
+
+    def request_authorization
+	response = handle_response :get, consumer.request_token_url
+	response.request_token
+    end
+
+    def authorize_url(token, permissions = [])
+	"https://infomeme.com/authorize?token=#{token}&permissions=#{permissions.join(',')}"
+    end
+
+    def authorize_with_verifier(token, secret, verifier)
+	req_token = OAuth::RequestToken.new(consumer, token, secret)
+	response = token_request(req_token, :get, finalize_get_url(consumer.access_token_url, {:oauth_verifier => verifier})) #do request with request_token
+	return false if response.error?
+	authorize_with_token(response.access_token.token, response.access_token.secret)
+    end
+
+    def authorize_with_token(token, secret)
+	access_token = OAuth::AccessToken.new(consumer, token, secret)
+	response = token_request(access_token, :get, "/oauth/verify_access")
+	return false if response.error?
+	self.verified_user = response.user_id
+	self.token = access_token
+	refresh_user_data
+	self
+    end
+
+    def authorize_with_credentials(login, password, permissions = nil)
+	req_token = request_authorization
+	response = put(consumer.authorize_url, {:oauth_token => req_token.token, :login => login, :password => password, :permissions => permissions || all_permissions.collect {|perm| perm.id}})
+	return false if response.error?
+	authorize_with_verifier(req_token.token, req_token.secret, response.verifier)
+    end
+
+    def deauthorize
+	self.verified_user = nil
+	self.token = OAuth::AccessToken.new(consumer)
+	refresh_user_data
+	self
+    end
+
+    def authorized?
+	! verified_user.nil?
+    end
+
+    def credentials(just = nil)
+	creds = {
+	    :login => verified_user,
+	    :token => token.token,
+	    :secret => token.secret,
+	}
+	creds.key?(just) ? creds[just] : creds
+    end
+
+    def inspect
+	@all_permissions ||= all_permissions
+	"#<#{self.class.name}: #{authorized? ? credentials.merge({:permissions => (@all_permissions || []).select {|perm| has_permission?(perm.id)}.collect {|perm| perm.name}}).inspect : 'not authorized'}>"
+    end
+
+    private
+	attr_accessor :consumer, :token, :verified_user
+
+	def refresh_user_data
+	    refresh_settings
+	    refresh_permissions
+	end
+end

data/lib/infomeme_client/communication.rb

@@ -0,0 +1,75 @@
+module InfomemeClient::Communication
+    def get(path, headers = {})
+	request(:get, path, headers)
+    end
+
+    def post(path, body = "", headers = {})
+	request(:post, path, body, headers)
+    end
+
+    def put(path, body = "", headers = {})
+	request(:put, path, body, headers)
+    end
+
+    def request(method, path, *args)
+	token_request(token, method, path, *args)
+    end
+
+    def handle_response(method, path, *args, &block)
+	response = request(method, path, *args)
+	response.raise_error
+	if block_given?
+	    if block.arity == 1
+		yield response
+	    else
+		yield unless response.error?
+	    end
+	else
+	    response
+	end
+    end
+
+    def extract_from_response(extract, method, path, *args)
+	handle_response(method, path, *args) do |resp|
+	    resp.extract(extract) unless resp.error?
+	end
+    end
+
+    def extract_or_response(extract, method, path, options, headers = {})
+	no_extract = options[:no_extract] || false
+	options.delete(:no_extract)
+	if [:put, :post].include?(method.to_sym)
+	    args = [method, path, options, headers]
+	else
+	    args = [method, finalize_get_url(path, options), headers]
+	end
+	if no_extract
+	    handle_response *args
+	else
+	    extract_from_response *args.unshift(extract)
+	end
+    end
+
+    private
+	def token_request(token, method, path, *args)
+	    body = [:post, :put].include?(method.to_sym) ? (args.shift || {}) : {}
+	    headers = args.shift || {}
+	    headers.store("Accept", "application/json") #override to use json
+	    if [:post, :put].include?(method.to_sym) && (! headers.key?("Content-Type") || headers["Content-Type"] == "application/json")
+		body = body.to_json unless body.is_a?(String)
+		headers.store("Content-Type", "application/json")
+	    end
+	    args.unshift headers
+	    args.unshift body if [:post, :put].include?(method.to_sym)
+	    begin
+		resp = token.request(method, path, *args).body
+		InfomemeClient::Response.new JSON.parse(resp)
+	    rescue => e
+		InfomemeClient::Response.new e
+	    end
+	end
+
+	def finalize_get_url(url, params)
+	    url + (url.include?("?") ? "&" : "?") + params.collect {|key, val| "#{key.to_s}=#{val.to_s}"}.join("&")
+	end
+end

data/lib/infomeme_client/entity_hash.rb

@@ -0,0 +1,66 @@
+class InfomemeClient::EntityHash
+    autoload :Comment, "infomeme_client/entity_hash/comment"
+    autoload :Invoice, "infomeme_client/entity_hash/invoice"
+    autoload :Meme, "infomeme_client/entity_hash/meme"
+    autoload :MemeType, "infomeme_client/entity_hash/meme_type"
+    autoload :Transaction, "infomeme_client/entity_hash/transaction"
+    autoload :User, "infomeme_client/entity_hash/user"
+
+    def initialize(hsh, no_freeze = false)
+	@hsh = hsh.inject({}) {|memo, keyvalue| #ripped from ActiveSupport, http://api.rubyonrails.org/classes/ActiveSupport/CoreExtensions/Hash/Keys.html#M000904
+	    key, value = keyvalue
+	    memo[(key.to_sym rescue key) || key] = map_values(value)
+	    memo
+	}
+	freeze unless no_freeze
+    end
+
+    def method_missing(sym)
+	@hsh.key?(sym) ? @hsh[sym] : super
+    end
+
+    def respond_to?(sym, include_private = false)
+	@hsh.key?(sym) ? true : super
+    end
+
+    def to_hash
+	@hsh.inject({}) do |memo, (key, value)|
+	    memo[key] = extract_values(value)
+	    memo
+	end
+    end
+
+    def freeze
+	@hsh.each do |key, val|
+	    deep_freeze(val)
+	end
+	@hsh.freeze
+	super
+    end
+
+    def id
+	@hsh.key?(:id) ? @hsh[:id] : super
+    end
+
+    private
+	def map_values(val)
+	    case
+		when val.is_a?(Hash) then InfomemeClient::EntityHash.new(val)
+		when val.is_a?(Array) then val.collect {|obj| map_values(obj)}
+		else val
+	    end
+	end
+
+	def extract_values(val)
+	    case
+		when val.is_a?(InfomemeClient::EntityHash) then val.to_hash
+		when val.is_a?(Array) then val.collect {|obj| extract_values(obj)}
+		else val
+	    end
+	end
+
+	def deep_freeze(val)
+	    val.each {|obj| deep_freeze(obj)} if val.is_a?(Array)
+	    val.freeze
+	end
+end

data/lib/infomeme_client/entity_hash/comment.rb

@@ -0,0 +1,2 @@
+class InfomemeClient::EntityHash::Comment < InfomemeClient::EntityHash
+end

data/lib/infomeme_client/entity_hash/invoice.rb

@@ -0,0 +1,2 @@
+class InfomemeClient::EntityHash::Invoice < InfomemeClient::EntityHash
+end

data/lib/infomeme_client/entity_hash/meme.rb

@@ -0,0 +1,45 @@
+class InfomemeClient::EntityHash::Meme < InfomemeClient::EntityHash
+    def initialize(meme, client)
+	super(meme, true)
+	@client = client
+	freeze
+    end
+
+    #todo: have_access?, published_by_me?, confirmed?, inactive?, incomplete?, has_upload?, etc.
+
+    def update(options = {})
+	@client.update_meme(id, options)
+    end
+
+    def delete
+	@client.delete_meme(id)
+    end
+
+    def confirm
+	@client.confirm_meme(id)
+    end
+
+    def activate
+	@client.activate_meme(id)
+    end
+
+    def deactivate
+	@client.deactivate_meme(id)
+    end
+
+    def upload_url(raw = false)
+	@client.upload_for_meme(id, raw)
+    end
+
+    def upload(file)
+	@client.upload(id, file)
+    end
+
+    def rate(rating)
+	@client.rate(id, rating)
+    end
+
+    def comment(comment)
+	@client.comment(id, comment)
+    end
+end

data/lib/infomeme_client/entity_hash/meme_type.rb

@@ -0,0 +1,2 @@
+class InfomemeClient::EntityHash::MemeType < InfomemeClient::EntityHash
+end

data/lib/infomeme_client/entity_hash/transaction.rb

@@ -0,0 +1,2 @@
+class InfomemeClient::EntityHash::Transaction < InfomemeClient::EntityHash
+end

data/lib/infomeme_client/entity_hash/user.rb

@@ -0,0 +1,2 @@
+class InfomemeClient::EntityHash::User < InfomemeClient::EntityHash
+end

data/lib/infomeme_client/errors.rb

@@ -0,0 +1,22 @@
+class InfomemeClient::Error < StandardError
+    class RequestFailed < self ; end
+    class InternalError < self ; end
+    class NoAccess < self ; end
+    class NotFound < self ; end
+
+    attr_reader :errors
+
+    def initialize(args)
+	@errors = args.shift
+	msg = args.shift
+	super(msg)
+    end
+
+    def message
+	"#{super} Errors: #{errors.inspect}"
+    end
+
+    def inspect
+	"<#{self.class.inspect} #{self.message}>"
+    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 :UserOrder, "infomeme_client/functions/user_order"
+
+    include Meme
+    include User
+    include UserMeme
+    include UserOrder
+
+    private
+	def get_memes(path, options = {}, headers = {})
+	    extract_or_response :memes, :get, path, options, headers
+	end
+end

data/lib/infomeme_client/functions/meme.rb

@@ -0,0 +1,23 @@
+module InfomemeClient::Functions::Meme
+    def browse(options = {})
+	get_memes "/memes", options
+    end
+
+    def search(search_token, options = {})
+	get_memes "/memes/search", options.merge({:search_token => search_token})
+    end
+
+    def meme_types
+	extract_from_response :meme_types, :get, "/memes/types"
+    end
+
+    def meme(meme_id)
+	handle_response :get, "/memes/#{meme_id}" do |resp|
+	    resp.extract(:meme, self) unless resp.error?
+	end
+    end
+
+    def meme_comments(meme_id, options = {})
+	extract_or_response :comments, :get, "/memes/#{meme_id}/comments", options
+    end
+end

data/lib/infomeme_client/functions/user.rb

@@ -0,0 +1,79 @@
+module InfomemeClient::Functions::User
+    attr_accessor :default_language
+
+    def register(email, username, password, firstname, lastname, optional_fields = {})
+	optional_fields.store(:language_code, optional_fields.key?(:language) ? optional_fields.delete(:language) : default_language) #language 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
+
+    def accept_tos
+	return false unless authorized?
+	handle_response :put, "/users/#{verified_user}/accept_tos" do
+	    refresh_settings and return true
+	end
+    end
+
+    def countries
+	handle_response :get, "/users/countries" do |resp|
+	    resp.countries unless resp.error?
+	end
+    end
+
+    def currencies
+	handle_response :get, "/users/currencies" do |resp|
+	    resp.currencies unless resp.error?
+	end
+    end
+
+    def languages
+	handle_response :get, "/users/languages" do |resp|
+	    resp.languages unless resp.error?
+	end
+    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,127 @@
+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?
+    skip_upload = options.key?(:skip_upload) && options[:skip_upload]
+    options[:image] = upload_image(options[:image]) if ! skip_upload && options.key?(:image) && ! options[:image].nil? && options[:image] != ""
+    meme_type = meme_type.id if meme_type.is_a?(InfomemeClient::EntityHash::MemeType)
+    meme_id = handle_response :post, "/users/#{verified_user}/memes", options.reject {|k,v| k == :file}.merge({:type => meme_type}) do |resp|
+      resp.meme_id unless resp.error?
+    end
+    upload(meme_id, options[:file]) if options.key?(:file)
+    meme_id
+  end
+  
+  def published_meme(meme_id)
+    return false unless authorized?
+    extract_from_response :meme, :get, "/users/#{verified_user}/memes/#{meme_id}"
+  end
+  
+  def update_meme(meme_id, options = {})
+    options[:image] = upload_image(options[:image]) if options.key?(:image)
+    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 ? resp.upload_url : finalize_get_url(resp.upload_url, generate_signature.merge(:meme_id => meme_id))) unless resp.error?
+    end
+  end
+  
+  def image_upload_for_memes
+    return false unless authorized?
+    handle_response :get, "/users/#{verified_user}/memes/image_upload_parameters" do |resp|
+      resp.image_upload_parameters unless resp.error?
+    end
+  end
+  
+  def upload(meme_id, file)
+    file = File.new(file) if file.is_a?(String)
+    upload_url = upload_for_meme(meme_id, true)
+    http_multipart(upload_url, generate_signature.merge({:meme_id => meme_id, :file => uploadio(file)})) if upload_url
+  end
+  
+  def upload_image(file)
+    file = File.new(file) if file.is_a?(String)
+    upload_params = image_upload_for_memes
+    File.basename(file.path) if upload_params && http_multipart("https://#{upload_params.bucket}.s3.amazonaws.com/", upload_params.to_hash.reject {|k,v| k == :bucket}.merge(:success_action_status => 200).to_a.push([:file, uploadio(file)])) #ensure file comes last (amazon requires the order)
+  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" => "https://api.infomeme.com", "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
+  
+  def http_multipart(url, params)
+    url = URI.parse(url)
+    req = Net::HTTP::Post::Multipart.new url.path, params
+    http = Net::HTTP.new(url.host, url.port)
+    http.use_ssl = url.scheme == "https"
+    resp = http.start {|http| http.request(req)}
+    resp.is_a?(Net::HTTPSuccess)
+  end
+  
+  def uploadio(file)
+    UploadIO.new(file, MIME::Types.type_for(file.path), file.path)
+  end
+end

data/lib/infomeme_client/functions/user_order.rb

@@ -0,0 +1,31 @@
+module InfomemeClient::Functions::UserOrder
+    def order(meme_id, source, options = {})
+	return false unless authorized?
+	handle_response :post, "/users/#{verified_user}/memes/#{meme_id}/order", options.merge(:source => source)
+    end
+
+    def order_with_balance(meme_id, options = {})
+	order(meme_id, 1, options)
+	refresh_settings
+	true
+    end
+
+    def order_with_paypal(meme_id, options = {})
+	order(meme_id, 3, options).paypal_url
+    end
+
+    def transactions(options = {})
+	return false unless authorized?
+	extract_or_response :transactions, :get, "/users/#{verified_user}/transactions", options
+    end
+
+    def invoices(options = {})
+	return false unless authorized?
+	extract_or_response :invoices, :get, "/users/#{verified_user}/invoices", options
+    end
+
+    def invoice(invoice_id)
+	return false unless authorized?
+	extract_from_response :invoice, :get, "/users/#{verified_user}/invoices/#{invoice_id}"
+    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(access_type, meme_id, oauth_token, oauth_nonce, oauth_timestamp, oauth_signature)
+	handle_response :post, "/meme_app/verify_access", {:access_type => access_type, :meme_id => meme_id, :verify_token => oauth_token, :verify_nonce => oauth_nonce, :verify_timestamp => oauth_timestamp, :verify_signature => oauth_signature}
+    end
+
+    def update_meme(meme_id, description, has_upload = true)
+	handle_response :put, "/meme_app/memes/#{meme_id}", {:description => description, :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,52 @@
+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 :transactions then InfomemeClient::EntityHash::Transaction
+	    when :invoice, :invoices then InfomemeClient::EntityHash::Invoice
+	    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/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/invoice.json

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

data/test/fixtures/users/invoices.json

@@ -0,0 +1 @@
+{"status":0,"message":"Success.","invoices":[{"amount_user":10.0,"meme":{"name":"test meme 1"}},{"amount_user":2.0,"meme":{"name":"test meme 2"}},{"amount_user":1.3,"meme":{"name":"test meme 3"}},{"amount_user":14.3,"meme":{"name":"test meme 4"}}],"pages":1,"count":4}

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/order_paypal.json

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

data/test/fixtures/users/permissions.json

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

data/test/fixtures/users/transactions.json

@@ -0,0 +1 @@
+{"status":0,"message":"Success.","transactions":[{"amount_user":10.0,"meme":{"name":"test meme 1"}},{"amount_user":2.0,"meme":{"name":"test meme 2"}},{"amount_user":1.3,"meme":{"name":"test meme 3"}},{"amount_user":14.3,"meme":{"name":"test meme 4"}}],"pages":1,"count":4}

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

data/test/test_communication.rb

@@ -0,0 +1,46 @@
+require "helper"
+
+class TestCommunication < Test::Unit::TestCase
+    def test_invalid_url
+	fake_request(:get, "/invalid_url", :body => "Error not found.", :status => ["404", "Not Found"])
+	assert_raise InfomemeClient::Error::RequestFailed do
+	    @im_client.handle_response :get, "/invalid_url"
+	end
+    end
+
+    def test_response_error
+	fake_request(:get, "/test_error", :body => fixture("response/error"), :status => ["400", "Bad Request"], :content_type => "application/json")
+	assert_raises InfomemeClient::Error do
+	    resp = @im_client.handle_response :get, "/test_error"
+	end
+	resp = @im_client.get "/test_error"
+	assert resp.error?
+	assert_respond_to resp, :errors
+	assert_kind_of InfomemeClient::EntityHash, resp.errors
+	assert_equal resp.errors.to_hash, {:test => {:test => "test error"}}
+    end
+
+    def test_response_ok
+	fake_request(:get, "/test_response", :body => fixture("response/test"), :content_type => "application/json")
+	resp = nil
+	assert_nothing_raised do
+	    resp = @im_client.handle_response :get, "/test_response"
+	end
+	assert_instance_of InfomemeClient::Response, resp
+	assert_respond_to resp, :test_message
+	assert_equal resp.test_message, "test message"
+    end
+
+    def test_response_extract
+	fake_request(:get, "/test_extract", :body => fixture("response/test_extract"), :content_type => "application/json")
+	resp = nil
+	assert_nothing_raised do
+	    resp = @im_client.handle_response :get, "/test_extract"
+	end
+	assert_instance_of InfomemeClient::Response, resp
+	assert_respond_to resp, :extract
+	assert_respond_to resp, :user
+	user = resp.extract(:user)
+	assert_instance_of InfomemeClient::EntityHash::User, user
+    end
+end

data/test/test_entity_hash.rb

@@ -0,0 +1,15 @@
+require "helper"
+
+class TestEntityHash < Test::Unit::TestCase
+    def test_entity_hash_attributes_available
+	eh = InfomemeClient::EntityHash.new({:foo => "bar"})
+	assert_respond_to eh, :foo
+	assert_equal "bar", eh.foo
+    end
+
+    def test_entity_hash_retrieve_hash
+	hash = {:foo => "bar", :bar => [{:foo => "bar"}]}
+	eh = InfomemeClient::EntityHash.new(hash)
+	assert_equal hash, eh.to_hash
+    end
+end

data/test/test_meme_functions.rb

@@ -0,0 +1,46 @@
+require "helper"
+
+class TestMemeFunctions < Test::Unit::TestCase
+    def test_browse
+	fake_request(:get, "/memes?page=1&pageSize=25&sort=date-asc", :body => fixture("memes/memes"), :content_type => "application/json")
+	check_paged :memes, @im_client.browse(:page => 1, :pageSize => 25, :sort => "date-asc", :no_extract => true)
+	check_list :memes, @im_client.browse(:page => 1, :pageSize => 25, :sort => "date-asc")
+    end
+
+    def test_search
+	fake_request(:get, "/memes/search?search_token=a&page=1&pageSize=25&sort=date-asc", :body => fixture("memes/memes"), :content_type => "application/json")
+	check_paged :memes, @im_client.search("a", :page => 1, :pageSize => 25, :sort => "date-asc", :no_extract => true)
+	check_list :memes, @im_client.search("a", :page => 1, :pageSize => 25, :sort => "date-asc")
+    end
+
+    def test_meme_types
+	fake_request(:get, "/memes/types", :body => fixture("memes/types"), :content_type => "application/json")
+	types = @im_client.meme_types
+	check_list :meme_types, types
+	assert types.size > 0
+	assert_respond_to types[0], :id
+	assert_respond_to types[0], :name
+	assert_respond_to types[0], :url
+	assert_respond_to types[0], :summary
+	assert_respond_to types[0], :description
+	assert_equal 1, types[0].id
+	assert_equal "TEST", types[0].name
+	assert_equal "http://test.url", types[0].url
+	assert_equal "test summary", types[0].summary
+	assert_equal "test description", types[0].description
+    end
+
+    def test_meme
+	fake_request(:get, "/memes/1", :body => fixture("memes/meme"), :content_type => "application/json")
+	meme = @im_client.meme(1)
+	check_eh :meme, meme
+	assert_respond_to meme, :name
+	assert_equal "test meme 1", meme.name
+    end
+
+    def test_meme_comments
+	fake_request(:get, "/memes/1/comments?page=1&pageSize=25", :body => fixture("memes/comments"), :content_type => "application/json")
+	check_paged :comments, @im_client.meme_comments(1, :page => 1, :pageSize => 25, :no_extract => true)
+	check_list :comments, @im_client.meme_comments(1, :page => 1, :pageSize => 25)
+    end
+end

data/test/test_permissions.rb

@@ -0,0 +1,25 @@
+require "helper"
+
+class TestPermissions < Test::Unit::TestCase
+    def test_all_permissions
+	fake_request(:get, "/oauth/permissions", :body => fixture("oauth/permissions"), :content_type => "application/json")
+	perms = @im_client.all_permissions
+	assert_instance_of Array, perms
+	all = {0 => "memes", 1 => "private_data", 2 => "order"}
+	perms.each do |perm|
+	    assert_instance_of InfomemeClient::EntityHash, perm
+	    assert_respond_to perm, :id
+	    assert_respond_to perm, :name
+	    assert_respond_to perm, :description
+	    assert all.key?(perm.id)
+	    assert_equal all[perm.id], perm.name
+	end
+    end
+
+    def test_refresh_permissions
+	authorize
+	(0..2).each do |perm|
+	    assert @im_client.has_permission?(perm)
+	end
+    end
+end

data/test/test_user_functions.rb

@@ -0,0 +1,15 @@
+require "helper"
+
+class TestUserFunctions < Test::Unit::TestCase
+    def test_user
+	fake_request(:get, "/users/test_user", :body => fixture("users/user_public"), :content_type => "application/json")
+	user = @im_client.user("test_user")
+	check_eh :user, user
+	assert_respond_to user, :username
+	assert_equal "test_user", user.username
+	assert_respond_to user, :comments
+	assert_equal 3, user.comments
+	assert_respond_to user, :ratings
+	assert_equal 3, user.ratings
+    end
+end

data/test/test_user_meme_functions.rb

@@ -0,0 +1,47 @@
+require "helper"
+
+class TestUserMemeFunctions < Test::Unit::TestCase
+    def test_library
+	fake_request(:get, "/users/test_user/memes?page=1&pageSize=25&sort=date-asc", :body => fixture("users/memes"), :content_type => "application/json")
+	authorize
+	check_paged :memes, @im_client.library(:page => 1, :pageSize => 25, :sort => "date-asc", :no_extract => true)
+	check_list :memes, @im_client.library(:page => 1, :pageSize => 25, :sort => "date-asc")
+    end
+
+    def test_published
+	fake_request(:get, "/users/test_user/memes/published?page=1&pageSize=25&sort=date-asc", :body => fixture("users/memes"), :content_type => "application/json")
+	authorize
+	check_paged :memes, @im_client.published(:page => 1, :pageSize => 25, :sort => "date-asc", :no_extract => true)
+	check_list :memes, @im_client.published(:page => 1, :pageSize => 25, :sort => "date-asc")
+    end
+
+    def test_inactive
+	fake_request(:get, "/users/test_user/memes/inactive?page=1&pageSize=25&sort=date-asc", :body => fixture("users/memes"), :content_type => "application/json")
+	authorize
+	check_paged :memes, @im_client.inactive(:page => 1, :pageSize => 25, :sort => "date-asc", :no_extract => true)
+	check_list :memes, @im_client.inactive(:page => 1, :pageSize => 25, :sort => "date-asc")
+    end
+
+    def test_incomplete
+	fake_request(:get, "/users/test_user/memes/incomplete?page=1&pageSize=25&sort=date-asc", :body => fixture("users/memes"), :content_type => "application/json")
+	authorize
+	check_paged :memes, @im_client.incomplete(:page => 1, :pageSize => 25, :sort => "date-asc", :no_extract => true)
+	check_list :memes, @im_client.incomplete(:page => 1, :pageSize => 25, :sort => "date-asc")
+    end
+
+    def test_comment
+	fake_request(:post, "/users/test_user/memes/1/comments", :body => fixture("response/ok"), :content_type => "application/json")
+	authorize
+	assert_nothing_raised do
+	    assert @im_client.comment(1, "test comment")
+	end
+    end
+
+    def test_rate
+	fake_request(:post, "/users/test_user/memes/1/rates", :body => fixture("response/ok"), :content_type => "application/json")
+	authorize
+	assert_nothing_raised do
+	    assert @im_client.rate(1, 1)
+	end
+    end
+end

data/test/test_user_order_functions.rb

@@ -0,0 +1,45 @@
+require "helper"
+
+class TestUserOrderFunctions < Test::Unit::TestCase
+    def test_order_with_balance
+	fake_request(:post, "/users/test_user/memes/1/order", :body => fixture("response/ok"), :content_type => "application/json")
+	authorize
+	assert_nothing_raised do
+	    assert @im_client.order_with_balance(1)
+	end
+    end
+
+    def test_order_with_paypal
+	fake_request(:post, "/users/test_user/memes/1/order", :body => fixture("users/order_paypal"), :content_type => "application/json")
+	authorize
+	assert_nothing_raised do
+	    assert_equal "test_paypal_url", @im_client.order_with_paypal(1)
+	end
+    end
+
+    def test_transactions
+	fake_request(:get, "/users/test_user/transactions?page=1&pageSize=25", :body => fixture("users/transactions"), :content_type => "application/json")
+	authorize
+	check_paged :transactions, @im_client.transactions(:page => 1, :pageSize => 25, :no_extract => true)
+	check_list :transactions, @im_client.transactions(:page => 1, :pageSize => 25)
+    end
+
+    def test_invoices
+	fake_request(:get, "/users/test_user/invoices?page=1&pageSize=25", :body => fixture("users/invoices"), :content_type => "application/json")
+	authorize
+	check_paged :invoices, @im_client.invoices(:page => 1, :pageSize => 25, :no_extract => true)
+	check_list :invoices, @im_client.invoices(:page => 1, :pageSize => 25)
+    end
+
+    def test_invoice
+	fake_request(:get, "/users/test_user/invoices/1", :body => fixture("users/invoice"), :content_type => "application/json")
+	authorize
+	invoice = @im_client.invoice(1)
+	check_eh :invoice, invoice
+	assert_respond_to invoice, :amount_user
+	assert_equal 10.0, invoice.amount_user
+	assert_respond_to invoice, :meme
+	assert_respond_to invoice.meme, :name
+	assert_equal "test meme 1", invoice.meme.name
+    end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: infomeme_client
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.3
   prerelease: 
 platform: ruby
 authors:
@@ -17,7 +17,56 @@ email: gem_info@infomeme.com
 executables: []
 extensions: []
 extra_rdoc_files: []
-files: []
+files:
+- lib/infomeme_client/errors.rb
+- lib/infomeme_client/entity_hash.rb
+- lib/infomeme_client/functions/user.rb
+- lib/infomeme_client/functions/user_order.rb
+- lib/infomeme_client/functions/meme.rb
+- lib/infomeme_client/functions/user_meme.rb
+- lib/infomeme_client/communication.rb
+- lib/infomeme_client/response.rb
+- lib/infomeme_client/base.rb
+- lib/infomeme_client/functions.rb
+- lib/infomeme_client/permissions.rb
+- lib/infomeme_client/entity_hash/user.rb
+- lib/infomeme_client/entity_hash/meme_type.rb
+- lib/infomeme_client/entity_hash/comment.rb
+- lib/infomeme_client/entity_hash/meme.rb
+- lib/infomeme_client/entity_hash/invoice.rb
+- lib/infomeme_client/entity_hash/transaction.rb
+- lib/infomeme_client/meme_application.rb
+- lib/infomeme_client.rb
+- test/helper.rb
+- test/test_user_order_functions.rb
+- test/test_permissions.rb
+- test/test_entity_hash.rb
+- test/test_communication.rb
+- test/fixtures/oauth/access_token.json
+- test/fixtures/oauth/permissions.json
+- test/fixtures/oauth/verify_access.json
+- test/fixtures/oauth/authorize.json
+- test/fixtures/oauth/request_token.json
+- test/fixtures/response/test.json
+- test/fixtures/response/ok.json
+- test/fixtures/response/test_extract.json
+- test/fixtures/response/error.json
+- test/fixtures/memes/meme.json
+- test/fixtures/memes/types.json
+- test/fixtures/memes/comments.json
+- test/fixtures/memes/memes.json
+- test/fixtures/users/transactions.json
+- test/fixtures/users/invoices.json
+- test/fixtures/users/user_public.json
+- test/fixtures/users/permissions.json
+- test/fixtures/users/memes.json
+- test/fixtures/users/user.json
+- test/fixtures/users/invoice.json
+- test/fixtures/users/order_paypal.json
+- test/test_authorization.rb
+- test/test_user_functions.rb
+- test/test_meme_functions.rb
+- test/test_user_meme_functions.rb
 has_rdoc: true
 homepage: https://github.com/Infomeme/infomeme_client
 licenses: []