rest-core 0.0.1

data/Rakefile

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+require "#{dir = File.dirname(__FILE__)}/task/gemgem"
+Gemgem.dir = dir
+
+($LOAD_PATH << File.expand_path("#{Gemgem.dir}/lib" )).uniq!
+
+desc 'Generate gemspec'
+task 'gem:spec' do
+  Gemgem.spec = Gemgem.create do |s|
+    require 'rest-core/version'
+    s.name        = 'rest-core'
+    s.version     = RestCore::VERSION
+    s.homepage    = 'https://github.com/cardinalblue/rest-core'
+    # s.executables = [s.name]
+
+    %w[].each{ |g| s.add_runtime_dependency(g) }
+    %w[rest-client rack yajl-ruby json json_pure ruby-hmac
+       webmock bacon rr rake].each{ |g| s.add_development_dependency(g) }
+
+    s.authors     = ['Cardinal Blue', 'Lin Jen-Shin (godfat)']
+    s.email       = ['dev (XD) cardinalblue.com']
+  end
+
+  Gemgem.write
+end

data/TODO.md

@@ -0,0 +1,17 @@
+# TODO
+
+## high
+
+* middleware revisit (how to initialize?)
+* what does false and nil mean in env?
+
+## medium
+
+* namespace issue
+* what about async request? yield callback? coroutine?
+* dependency?
+
+## low
+
+* config loader
+* test utility

data/example/facebook.rb

@@ -0,0 +1,145 @@
+
+# simple client
+
+require 'rest-core'
+
+RestCore::Builder.client('Facebook', :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  , method(:puts)
+  use s::Cache         , {}, nil
+  use s::ErrorHandler  , lambda{ |env| raise ::Facebook::Error.call(env) }
+  use s::ErrorDetector , lambda{ |env| env[s::RESPONSE_BODY]['error'] ||
+                                       env[s::RESPONSE_BODY]['error_code'] }
+  use s::JsonDecode    , true
+
+  use s::Defaults      , :data     => lambda{{}},
+                         :old_site => 'https://api.facebook.com/'
+
+  run s::RestClient
+end
+
+class Facebook::Error < RuntimeError
+  include RestCore
+
+  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)
+    new(error, url)
+  end
+end
+
+module Facebook::Client
+  include RestCore
+
+  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
+
+  # cookies, app_id, secrect related below
+
+  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 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))
+    request(opts, [:get, uri], &cb)
+  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
+
+  protected
+  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
+end
+
+Facebook.send(:include, Facebook::Client)

data/example/github.rb

@@ -0,0 +1,21 @@
+
+# simple client
+
+require 'rest-core'
+
+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::Oauth2Query  , 'access_token', nil
+
+  use s::CommonLogger , method(:puts)
+  use s::Cache        , {}, nil
+  use s::ErrorHandler , lambda{|env| raise env[s::RESPONSE_BODY]['message']}
+  use s::ErrorDetector, lambda{|env| env[s::RESPONSE_HEADERS]['status'].
+                                     first !~ /^2/}
+  use s::JsonDecode   , true
+
+  run s::RestClient
+end

data/lib/rest-core.rb

@@ -0,0 +1,48 @@
+
+module RestCore
+  REQUEST_METHOD   = 'REQUEST_METHOD'
+  REQUEST_PATH     = 'REQUEST_PATH'
+  REQUEST_QUERY    = 'REQUEST_QUERY'
+  REQUEST_PAYLOAD  = 'REQUEST_PAYLOAD'
+  REQUEST_HEADERS  = 'REQUEST_HEADERS'
+
+  RESPONSE_BODY    = 'RESPONSE_BODY'
+  RESPONSE_STATUS  = 'RESPONSE_STATUS'
+  RESPONSE_HEADERS = 'RESPONSE_HEADERS'
+
+  ASK              = 'core.ask'
+  FAIL             = 'core.fail'
+  LOG              = 'core.log'
+
+  # core utilities
+  autoload :Builder       , 'rest-core/builder'
+  autoload :Client        , 'rest-core/client'
+  autoload :Event         , 'rest-core/event'
+  autoload :Middleware    , 'rest-core/middleware'
+  autoload :Wrapper       , 'rest-core/wrapper'
+
+  # oauth1 utilities
+  autoload :ClientOauth1  , 'rest-core/client_oauth1'
+
+  # misc utilities
+  autoload :Hmac          , 'rest-core/util/hmac'
+
+  # middlewares
+  autoload :Cache         , 'rest-core/middleware/cache'
+  autoload :CommonLogger  , 'rest-core/middleware/common_logger'
+  autoload :DefaultHeaders, 'rest-core/middleware/default_headers'
+  autoload :DefaultQuery  , 'rest-core/middleware/default_query'
+  autoload :DefaultSite   , 'rest-core/middleware/default_site'
+  autoload :Defaults      , 'rest-core/middleware/defaults'
+  autoload :ErrorDetector , 'rest-core/middleware/error_detector'
+  autoload :ErrorDetectorHttp, 'rest-core/middleware/error_detector_http'
+  autoload :ErrorHandler  , 'rest-core/middleware/error_handler'
+  autoload :JsonDecode    , 'rest-core/middleware/json_decode'
+  autoload :Oauth1Header  , 'rest-core/middleware/oauth1_header'
+  autoload :Oauth2Query   , 'rest-core/middleware/oauth2_query'
+  autoload :Timeout       , 'rest-core/middleware/timeout'
+
+  # apps
+  autoload :Ask           , 'rest-core/app/ask'
+  autoload :RestClient    , 'rest-core/app/rest-client'
+end

data/lib/rest-core/app/ask.rb

@@ -0,0 +1,11 @@
+
+require 'rest-core/middleware'
+
+require 'restclient'
+
+class RestCore::Ask
+  include RestCore::Middleware
+  def call env
+    env
+  end
+end

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

@@ -0,0 +1,24 @@
+
+require 'rest-core/middleware'
+
+require 'restclient'
+
+class RestCore::RestClient
+  include RestCore::Middleware
+  def call env
+    respond(env,
+            ::RestClient::Request.execute(:method  => env[REQUEST_METHOD ],
+                                          :url     => request_uri(env)    ,
+                                          :payload => env[REQUEST_PAYLOAD],
+                                          :headers => env[REQUEST_HEADERS]))
+
+  rescue ::RestClient::Exception => e
+    respond(env, e.response)
+  end
+
+  def respond env, response
+    env.merge(RESPONSE_BODY    => response.body,
+              RESPONSE_STATUS  => response.code,
+              RESPONSE_HEADERS => response.raw_headers)
+  end
+end

data/lib/rest-core/builder.rb

@@ -0,0 +1,24 @@
+
+require 'rest-core/client'
+require 'rest-core/wrapper'
+
+class RestCore::Builder
+  include RestCore
+  include Wrapper
+
+  def self.client prefix, *attrs, &block
+    new(&block).to_client(prefix, *attrs)
+  end
+
+  def to_client prefix, *attrs
+    # struct = Struct.new(*members, *attrs) if RUBY_VERSION >= 1.9.2
+    struct = Struct.new(*(members + attrs))
+    client = Class.new(struct)
+    client.send(:include, Client)
+    Object.const_set( prefix , client)
+    client.const_set('Struct', struct)
+    class << client; attr_reader :builder; end
+    client.instance_variable_set(:@builder, self)
+    client
+  end
+end

data/lib/rest-core/client.rb

@@ -0,0 +1,278 @@
+
+require 'rest-core'
+
+module RestCore::Client
+  include RestCore
+
+  Unserializable = [Proc, Method, IO]
+
+  def self.included mod
+    # honor default attributes
+    src = mod.members.map{ |name|
+      <<-RUBY
+        def #{name}
+          if (r = super).nil?
+            self.#{name} = default_#{name}
+          else
+            r
+          end
+        end
+
+        def default_#{name} app=app
+          if app.respond_to?(:#{name})
+            app.#{name}({})
+          elsif app.respond_to?(:wrapped)
+            default_#{name}(app.wrapped) ||
+            default_#{name}(app.app)
+          elsif app.respond_to?(:app)
+            default_#{name}(app.app)
+          else
+            nil
+          end
+        end
+        private :default_#{name}
+
+        self
+      RUBY
+    }
+    # if RUBY_VERSION < '1.9.2'
+    src << <<-RUBY if mod.members.first.kind_of?(String)
+      def members
+        super.map(&:to_sym)
+      end
+      self
+    RUBY
+    # end
+    accessor = Module.new.module_eval(src.join("\n"), __FILE__, __LINE__)
+    mod.const_set('Accessor', accessor)
+    mod.send(:include, accessor)
+  end
+
+  attr_reader :app, :ask
+  def initialize o={}
+    @app ||= self.class.builder.to_app
+    @ask ||= self.class.builder.to_app(Ask)
+    o.each{ |key, value| send("#{key}=", value) if respond_to?("#{key}=") }
+  end
+
+  def attributes
+    Hash[each_pair.map{ |k, v| [k, send(k)] }]
+  end
+
+  def inspect
+    "#<struct #{self.class.name} #{attributes.map{ |k, v|
+      "#{k}=#{v.inspect}" }.join(', ')}>"
+  end
+
+  def lighten! o={}
+    attributes.each{ |k, v| vv = case v;
+                                   when  Hash; lighten_hash(v)
+                                   when Array; lighten_array(v)
+                                   when *Unserializable; false
+                                   else v
+                                  end
+                            send("#{k}=", vv)}
+    initialize(o)
+    @app, @ask = lighten_app(app), lighten_app(ask)
+    self
+  end
+
+  def lighten o={}
+    dup.lighten!(o)
+  end
+
+  def url path, query={}, opts={}
+    Middleware.request_uri(
+      ask.call(build_env({
+        REQUEST_PATH  => path,
+        REQUEST_QUERY => query,
+        ASK           => true}.merge(opts))))
+  end
+
+  # extra options:
+  #   auto_decode: Bool # decode with json or not in this API request
+  #                     # default: auto_decode in rest-graph instance
+  #       timeout: Int  # the timeout for this API request
+  #                     # default: timeout in rest-graph instance
+  #        secret: Bool # use secret_acccess_token or not
+  #                     # default: false
+  #         cache: Bool # use cache or not; if it's false, update cache, too
+  #                     # default: true
+  #    expires_in: Int  # control when would the cache be expired
+  #                     # default: nil
+  #         async: Bool # use eventmachine for http client or not
+  #                     # default: false, but true in aget family
+  #       headers: Hash # additional hash you want to pass
+  #                     # default: {}
+  def get    path, query={}, opts={}, &cb
+    request(opts, [:get   , path, query], &cb)
+  end
+
+  def delete path, query={}, opts={}, &cb
+    request(opts, [:delete, path, query], &cb)
+  end
+
+  def post   path, payload={}, query={}, opts={}, &cb
+    request(opts, [:post  , path, query, payload], &cb)
+  end
+
+  def put    path, payload={}, query={}, opts={}, &cb
+    request(opts, [:put   , path, query, payload], &cb)
+  end
+
+  # request by eventmachine (em-http)
+
+  def aget    path, query={}, opts={}, &cb
+    get(path, query, {:async => true}.merge(opts), &cb)
+  end
+
+  def adelete path, query={}, opts={}, &cb
+    delete(path, query, {:async => true}.merge(opts), &cb)
+  end
+
+  def apost   path, payload={}, query={}, opts={}, &cb
+    post(path, payload, query, {:async => true}.merge(opts), &cb)
+  end
+
+  def aput    path, payload={}, query={}, opts={}, &cb
+    put(path, payload, query, {:async => true}.merge(opts), &cb)
+  end
+
+  def multi reqs, opts={}, &cb
+    request({:async => true}.merge(opts), *reqs, &cb)
+  end
+
+  def request opts, *reqs
+    req = reqs.first
+    response = app.call(build_env({
+      REQUEST_METHOD  => req[0]         ,
+      REQUEST_PATH    => req[1]         ,
+      REQUEST_QUERY   => req[2]         ,
+      REQUEST_PAYLOAD => req[3]         ,
+      REQUEST_HEADERS => opts['headers'],
+      FAIL            => []             ,
+      LOG             => []}.merge(opts)))[RESPONSE_BODY]
+
+    if block_given?
+      yield(response)
+    else
+      response
+    end
+  end
+  # ------------------------ instance ---------------------
+
+
+
+  protected
+  def build_env env={}
+    string_keys(attributes).merge(string_keys(env))
+  end
+
+  def string_keys hash
+    hash.inject({}){ |r, (k, v)|
+      if v.kind_of?(Hash)
+        r[k.to_s] = case k.to_s
+                      when REQUEST_QUERY, REQUEST_PAYLOAD, REQUEST_HEADERS
+                        string_keys(v)
+                      else;         v
+                    end
+      else
+        r[k.to_s] = v
+      end
+      r
+    }
+  end
+
+  def lighten_hash hash
+    Hash[hash.map{ |(key, value)|
+      case value
+        when  Hash; lighten_hash(value)
+        when Array; lighten_array(value)
+        when *Unserializable; [key, nil]
+        else [key, value]
+      end
+    }]
+  end
+
+  def lighten_array array
+    array.map{ |value|
+      case value
+        when  Hash; lighten_hash(value)
+        when Array; lighten_array(value)
+        when *Unserializable; nil
+        else value
+      end
+    }.compact
+  end
+
+  def lighten_app app
+    members = if app.class.respond_to?(:members)
+                app.class.members.map{ |key|
+                  case value = app.send(key, {})
+                    when  Hash; lighten_hash(value)
+                    when Array; lighten_array(value)
+                    when *Unserializable; nil
+                    else value
+                  end
+                }
+              else
+                []
+              end
+
+    if app.respond_to?(:app) && app.app
+      wrapped = if app.respond_to?(:wrapped) && app.wrapped
+                  lighten_app(app.wrapped)
+                else
+                  nil
+                end
+      app.class.new(lighten_app(app.app), *members){
+        @wrapped = wrapped if wrapped
+      }
+    else
+      app.class.new(*members)
+    end
+  end
+
+  private
+  def request_em opts, reqs
+    start_time = Time.now
+    rs = reqs.map{ |(meth, path, query, payload)|
+      r = EM::HttpRequest.new(path).send(meth, :body  => payload,
+                                               :head  => build_headers(opts),
+                                               :query => query)
+      if cached = cache_get(opts, path)
+        # TODO: this is hack!!
+        r.instance_variable_set('@response', cached)
+        r.instance_variable_set('@state'   , :finish)
+        r.on_request_complete
+        r.succeed(r)
+      else
+        r.callback{
+          cache_for(opts, path, meth, r.response)
+          log(env.merge('event' =>
+            Event::Requested.new(Time.now - start_time, path)))
+        }
+        r.error{
+          log(env.merge('event' =>
+            Event::Failed.new(Time.now - start_time, path)))
+        }
+      end
+      r
+    }
+    EM::MultiRequest.new(rs){ |m|
+      # TODO: how to deal with the failed?
+      clients = m.responses[:succeeded]
+      results = clients.map{ |client|
+        post_request(opts, client.uri, client.response)
+      }
+
+      if reqs.size == 1
+        yield(results.first)
+      else
+        log(env.merge('event' => Event::MultiDone.new(Time.now - start_time,
+          clients.map(&:uri).join(', '))))
+        yield(results)
+      end
+    }
+  end
+end