rest-core 0.0.1

data/lib/rest-core/client/github.rb

@@ -0,0 +1,19 @@
+
+RestCore::Builder.client('Github') do
+  s = self.class # this is only for ruby 1.8!
+  use s::Timeout       , 10
+
+  use s::DefaultSite   , 'https://api.github.com/'
+  use s::DefaultHeaders, {'Accept' => 'application/json'}
+  use s::Oauth2Query   , 'access_token', nil
+
+  use s::CommonLogger  , lambda{|obj|obj}
+  use s::Cache         , {}, nil do
+    use s::ErrorHandler , lambda{|env| raise env[s::RESPONSE_BODY]['message']}
+    use s::ErrorDetectorHttp
+    use s::JsonDecode   , true
+    run s::Ask
+  end
+
+  run s::RestClient
+end

data/lib/rest-core/client/linkedin.rb

@@ -0,0 +1,57 @@
+
+RestCore::Builder.client('Linkedin', :data) do
+  s = self.class # this is only for ruby 1.8!
+  use s::Timeout       , 10
+
+  use s::DefaultSite   , 'https://api.linkedin.com/'
+  use s::DefaultHeaders, {'Accept' => 'application/json'}
+  use s::DefaultQuery  , {'format' => 'json'}
+
+  use s::Oauth1Header  ,
+    'uas/oauth/requestToken', 'uas/oauth/accessToken',
+    'https://www.linkedin.com/uas/oauth/authorize'
+
+  use s::CommonLogger  , method(:puts)
+
+  use s::Cache         , {}, nil do
+    use s::ErrorHandler , lambda{|env|
+      if (body = env[s::RESPONSE_BODY]).kind_of?(Hash)
+        raise body['message']
+      else
+        raise body
+      end
+    }
+    use s::ErrorDetectorHttp
+    use s::JsonDecode    , true
+    run s::Ask
+  end
+
+  use s::Defaults      , :data     => lambda{{}}
+
+  run s::RestClient
+end
+
+module Linkedin::Client
+  include RestCore
+
+  def oauth_token
+    data['oauth_token'] if data.kind_of?(Hash)
+  end
+  def oauth_token=  token
+    data['oauth_token'] = token if data.kind_of?(Hash)
+  end
+  def oauth_token_secret
+    data['oauth_token_secret'] if data.kind_of?(Hash)
+  end
+  def oauth_token_secret=  secret
+    data['oauth_token_secret'] = secret if data.kind_of?(Hash)
+  end
+
+  private
+  def set_token query
+    self.data = query
+  end
+end
+
+Linkedin.send(:include, RestCore::ClientOauth1)
+Linkedin.send(:include, Linkedin::Client)

data/lib/rest-core/client/rest-graph.rb

@@ -0,0 +1,262 @@
+
+require 'rest-core'
+require 'rest-core/util/hmac'
+
+# optional gem
+begin; require 'rack'; rescue LoadError; end
+
+RestCore::Builder.client('RestGraph', :data, :app_id, :secret, :old_site) do
+  s = self.class # this is only for ruby 1.8!
+  use s::Timeout       , 10
+
+  use s::DefaultSite   , 'https://graph.facebook.com/'
+  use s::DefaultHeaders, {'Accept'          => 'application/json',
+                          'Accept-Language' => 'en-us'}
+  use s::Oauth2Query   , 'access_token', nil
+
+  use s::CommonLogger  , lambda{|obj|obj}
+
+  use s::Cache         , {}, nil do
+    use s::ErrorHandler  , lambda{ |env| raise ::RestGraph::Error.call(env) }
+    use s::ErrorDetector , lambda{ |env|
+      if env[s::RESPONSE_BODY].kind_of?(Hash)
+        env[s::RESPONSE_BODY]['error'] ||
+        env[s::RESPONSE_BODY]['error_code']
+      end}
+
+    use s::JsonDecode    , true
+    run s::Ask
+  end
+
+  use s::Defaults      , :data     => lambda{{}},
+                         :old_site => 'https://api.facebook.com/'
+
+  run s::RestClient
+end
+
+class RestGraph::Error < RuntimeError
+  include RestCore
+  class AccessToken        < RestGraph::Error; end
+  class InvalidAccessToken < AccessToken     ; end
+  class MissingAccessToken < AccessToken     ; end
+
+  attr_reader :error, :url
+  def initialize error, url=''
+    @error, @url = error, url
+    super("#{error.inspect} from #{url}")
+  end
+
+  def self.call env
+    error, url = env[RESPONSE_BODY], Middleware.request_uri(env)
+    return new(env[FAIL], url) unless error.kind_of?(Hash)
+    if    invalid_token?(error)
+      InvalidAccessToken.new(error, url)
+    elsif missing_token?(error)
+      MissingAccessToken.new(error, url)
+    else
+      new(error, url)
+    end
+  end
+
+  def self.invalid_token? error
+    (%w[OAuthInvalidTokenException
+        OAuthException].include?((error['error'] || {})['type'])) ||
+    (error['error_code'] == 190) # Invalid OAuth 2.0 Access Token
+  end
+
+  def self.missing_token? error
+    (error['error'] || {})['message'] =~ /^An active access token/ ||
+    (error['error_code'] == 104) # Requires valid signature
+  end
+end
+
+module RestGraph::Client
+  include RestCore
+
+  def self.included mod
+    mod.send(:alias_method, :auto_decode , :json_decode )
+    mod.send(:alias_method, :auto_decode=, :json_decode=)
+  end
+
+  def oauth_token
+    data['access_token'] || data['oauth_token'] if data.kind_of?(Hash)
+  end
+  def oauth_token=  token
+    data['access_token'] = token if data.kind_of?(Hash)
+  end
+  alias_method :access_token , :oauth_token
+  alias_method :access_token=, :oauth_token=
+
+  def secret_oauth_token ; "#{app_id}|#{secret}"           ; end
+  alias_method :secret_access_token, :secret_oauth_token
+
+  def accept             ; headers['Accept']               ; end
+  def accept=         val; headers['Accept']          = val; end
+  def lang               ; headers['Accept-Language']      ; end
+  def lang=           val; headers['Accept-Language'] = val; end
+
+  def authorized?        ; !!oauth_token                   ; end
+
+  def next_page hash, opts={}, &cb
+    if hash['paging'].kind_of?(Hash) && hash['paging']['next']
+      request(opts, [:get, URI.encode(hash['paging']['next'])], &cb)
+    else
+      yield(nil) if block_given?
+    end
+  end
+
+  def prev_page hash, opts={}, &cb
+    if hash['paging'].kind_of?(Hash) && hash['paging']['previous']
+      request(opts, [:get, URI.encode(hash['paging']['previous'])], &cb)
+    else
+      yield(nil) if block_given?
+    end
+  end
+  alias_method :previous_page, :prev_page
+
+  def for_pages hash, pages=1, opts={}, kind=:next_page, &cb
+    if pages > 1
+      merge_data(send(kind, hash, opts){ |result|
+        yield(result.freeze) if block_given?
+        for_pages(result, pages - 1, opts, kind, &cb) if result
+      }, hash)
+    else
+      yield(nil) if block_given?
+      hash
+    end
+  end
+
+  # cookies, app_id, secrect related below
+
+  def parse_rack_env! env
+    env['HTTP_COOKIE'].to_s =~ /fbs_#{app_id}=([^\;]+)/
+    self.data = parse_fbs!($1)
+  end
+
+  def parse_cookies! cookies
+    self.data = parse_fbs!(cookies["fbs_#{app_id}"])
+  end
+
+  def parse_fbs! fbs
+    self.data = check_sig_and_return_data(
+      # take out facebook sometimes there but sometimes not quotes in cookies
+      Rack::Utils.parse_query(fbs.to_s.sub(/^"/, '').sub(/"$/, '')))
+  end
+
+  def parse_json! json
+    self.data = json &&
+      check_sig_and_return_data(JsonDecode.json_decode(json))
+  rescue JsonDecode::ParseError
+    self.data = nil
+  end
+
+  def fbs
+    "#{fbs_without_sig(data).join('&')}&sig=#{calculate_sig(data)}"
+  end
+
+  # facebook's new signed_request...
+
+  def parse_signed_request! request
+    sig_encoded, json_encoded = request.split('.')
+    sig,  json = [sig_encoded, json_encoded].map{ |str|
+      "#{str.tr('-_', '+/')}==".unpack('m').first
+    }
+    self.data = check_sig_and_return_data(
+                  JsonDecode.json_decode(json).merge('sig' => sig)){
+                    Hmac.sha256(secret, json_encoded)
+                  }
+  rescue JsonDecode::ParseError
+    self.data = nil
+  end
+
+  # oauth related
+
+  def authorize_url opts={}
+    url('oauth/authorize',
+        {:client_id => app_id, :access_token => nil}.merge(opts))
+  end
+
+  def authorize! opts={}
+    query = {:client_id => app_id, :client_secret => secret}.merge(opts)
+    self.data = Rack::Utils.parse_query(
+                  request({:auto_decode => false}.merge(opts),
+                          [:get, url('oauth/access_token', query)]))
+  end
+
+  # old rest facebook api, i will definitely love to remove them someday
+
+  def old_rest path, query={}, opts={}, &cb
+    uri = url("method/#{path}", {:format => 'json'}.merge(query),
+              {:site => old_site}.merge(opts))
+    if opts[:post]
+      request(
+        opts.merge('cache.key' => uri, 'cache.post' => true),
+        [:post,
+         url("method/#{path}", {:format => 'json'},
+             {:site => old_site}.merge(opts)),
+         {}, query],
+        &cb)
+    else
+      request(opts, [:get, uri], &cb)
+    end
+  end
+
+  def secret_old_rest path, query={}, opts={}, &cb
+    old_rest(path, query, {:secret => true}.merge(opts), &cb)
+  end
+
+  def fql code, query={}, opts={}, &cb
+    old_rest('fql.query', {:query => code}.merge(query), opts, &cb)
+  end
+
+  def fql_multi codes, query={}, opts={}, &cb
+    old_rest('fql.multiquery',
+      {:queries => JsonDecode.json_encode(codes)}.merge(query), opts, &cb)
+  end
+
+  def exchange_sessions query={}, opts={}, &cb
+    q = {:client_id => app_id, :client_secret => secret,
+         :type => 'client_cred'}.merge(query)
+    request(opts, [:post, url('oauth/exchange_sessions', q)], &cb)
+  end
+
+  protected
+  def build_env env={}
+    super(env.inject({}){ |r, (k, v)|
+      case k.to_s
+        when 'auto_decode'; r['json_decode' ] = v
+        when 'secret'     ; r['oauth_token' ] = secret_oauth_token
+        when 'cache'      ; r['cache.update'] = !!!v
+        else              ; r[k.to_s]         = v
+      end
+      r
+    })
+  end
+
+  def check_sig_and_return_data cookies
+    cookies if secret && if block_given?
+                           yield
+                         else
+                           calculate_sig(cookies)
+                         end == cookies['sig']
+  end
+
+  def calculate_sig cookies
+    Digest::MD5.hexdigest(fbs_without_sig(cookies).join + secret)
+  end
+
+  def fbs_without_sig cookies
+    cookies.reject{ |(k, v)| k == 'sig' }.sort.map{ |a| a.join('=') }
+  end
+
+  def merge_data lhs, rhs
+    [lhs, rhs].each{ |hash|
+      return rhs.reject{ |k, v| k == 'paging' } if
+        !hash.kind_of?(Hash) || !hash['data'].kind_of?(Array)
+    }
+    lhs['data'].unshift(*rhs['data'])
+    lhs
+  end
+end
+
+RestGraph.send(:include, RestGraph::Client)

data/lib/rest-core/client/twitter.rb

@@ -0,0 +1,59 @@
+
+RestCore::Builder.client('Twitter', :data) do
+  s = self.class # this is only for ruby 1.8!
+  use s::Timeout       , 10
+
+  use s::DefaultSite   , 'https://api.twitter.com/'
+  use s::DefaultHeaders, {'Accept' => 'application/json'}
+
+  use s::Oauth1Header  ,
+    'oauth/request_token', 'oauth/access_token', 'oauth/authorize'
+
+  use s::CommonLogger  , method(:puts)
+
+  use s::Cache         , {}, nil do
+    use s::ErrorHandler  , lambda{ |env|
+      if (body = env[s::RESPONSE_BODY]).kind_of?(Hash)
+        raise body['error']
+      else
+        raise body
+      end
+    }
+    use s::ErrorDetectorHttp
+    use s::JsonDecode    , true
+    run s::Ask
+  end
+
+  use s::Defaults      , :data     => lambda{{}}
+
+  run s::RestClient
+end
+
+module Twitter::Client
+  include RestCore
+
+  def oauth_token
+    data['oauth_token'] if data.kind_of?(Hash)
+  end
+  def oauth_token=  token
+    data['oauth_token'] = token if data.kind_of?(Hash)
+  end
+  def oauth_token_secret
+    data['oauth_token_secret'] if data.kind_of?(Hash)
+  end
+  def oauth_token_secret=  secret
+    data['oauth_token_secret'] = secret if data.kind_of?(Hash)
+  end
+
+  def tweet status, opt={}
+    post('1/statuses/update.json', {:status => status}.merge(opt))
+  end
+
+  private
+  def set_token query
+    self.data = query
+  end
+end
+
+Twitter.send(:include, RestCore::ClientOauth1)
+Twitter.send(:include,  Twitter::Client)

data/lib/rest-core/client_oauth1.rb

@@ -0,0 +1,25 @@
+
+require 'rack'
+
+module RestCore::ClientOauth1
+  include RestCore
+
+  def authorize_url!
+    set_token(Rack::Utils.parse_query(
+      post(request_token_path, {}, {}, {:json_decode => false})))
+
+    url(authorize_path, :oauth_token => oauth_token, :format => false)
+  end
+
+  def authorize! verifier
+    set_token(Rack::Utils.parse_query(
+      post(access_token_path, {}, {}, {:verifier => verifier,
+                                       :json_decode => false})))
+  end
+
+  private
+  def set_token query
+    self.oauth_token        = query['oauth_token']
+    self.oauth_token_secret = query['oauth_token_secret']
+  end
+end

data/lib/rest-core/event.rb

@@ -0,0 +1,17 @@
+
+module RestCore
+  EventStruct = Struct.new(:duration, :message) unless
+    RestCore.const_defined?(:EventStruct)
+
+  class Event < EventStruct
+    # self.class.name[/(?<=::)\w+$/] if RUBY_VERSION >= '1.9.2'
+    def name; self.class.name[/::(\w+)$/, 1]        ; end
+    def to_s; "spent #{duration} #{name} #{message}"; end
+  end
+  class Event::MultiDone    < Event; end
+  class Event::Requested    < Event; end
+  class Event::CacheHit     < Event; end
+  class Event::CacheCleared < Event; end
+  class Event::Failed       < Event; end
+  class Event::WithHeader   < Event; end
+end

data/lib/rest-core/middleware.rb

@@ -0,0 +1,53 @@
+
+require 'rest-core'
+
+require 'cgi'
+
+module RestCore::Middleware
+  include RestCore
+
+  def self.included mod
+    mod.send(:include, RestCore)
+    mod.send(:attr_reader, :app)
+    return unless mod.respond_to?(:members)
+    src = mod.members.map{ |member| <<-RUBY }
+      def #{member} env
+        if    env.key?('#{member}')
+          env['#{member}']
+        else
+              @#{member}
+        end
+      end
+    RUBY
+    args      = [:app] + mod.members
+    para_list = args.map{ |a| "#{a}=nil"}.join(', ')
+    args_list = args                     .join(', ')
+    ivar_list = args.map{ |a| "@#{a}"   }.join(', ')
+    src << <<-RUBY
+      def initialize #{para_list}
+        #{ivar_list} = #{args_list}
+      end
+      self
+    RUBY
+    accessor = Module.new.module_eval(src.join("\n"), __FILE__, __LINE__)
+    mod.const_set(:Accessor, accessor)
+    mod.send(:include, accessor)
+  end
+
+  def call env     ; app.call(env)                               ; end
+  def fail env, obj; env.merge(FAIL => (env[FAIL] || []) + [obj]); end
+  def log  env, obj; env.merge(LOG  => (env[LOG]  || []) + [obj]); end
+
+  module_function
+  def request_uri env
+    # compacting the hash
+    if (query = (env[REQUEST_QUERY] || {}).select{ |k, v| v }).empty?
+      env[REQUEST_PATH].to_s
+    else
+      q = if env[REQUEST_PATH] =~ /\?/ then '&' else '?' end
+      "#{env[REQUEST_PATH]}#{q}" \
+      "#{query.map{ |(k, v)| "#{k}=#{CGI.escape(v.to_s)}" }.join('&')}"
+    end
+  end
+  public :request_uri
+end