rest-core 0.3.0 → 0.4.0.pre.0

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

@@ -0,0 +1,89 @@
+
+require 'rest-core'
+
+require 'time' # for Time.parse
+
+RestCore::Flurry = RestCore::Builder.client(:api_key, :access_code) do
+  s = self.class # this is only for ruby 1.8!
+
+  use s::DefaultSite   , 'http://api.flurry.com/'
+  use s::DefaultHeaders, {'Accept' => 'application/json'}
+  use s::DefaultQuery  , {}
+
+  use s::CommonLogger  , nil
+  use s::Cache         , {}, 3600 do
+    use s::ErrorHandler, lambda{|env| raise env[s::RESPONSE_BODY]['message']}
+    use s::ErrorDetectorHttp
+    use s::JsonDecode  , true
+  end
+
+  run s::RestClient
+end
+
+module RestCore::Flurry::Client
+  # see: http://wiki.flurry.com/index.php?title=AppInfo
+  # >> f.app_info
+  # => {"@platform"=>"iPhone", "@name"=>"PicCollage",
+  #     "@createdDate"=>"2011-07-24", "@category"=>"Photography",
+  #     "@version"=>"1.0", "@generatedDate"=>"9/15/11 7:08 AM",
+  #     "version"=>[{"@name"=>"2.1", ...
+  def app_info query={}
+    get('appInfo/getApplication', query)
+  end
+
+  # see: http://wiki.flurry.com/index.php?title=EventMetrics
+  # >> f.event_matrics(:startDate => '2011-09-14', :endDate => '2011-09-15')
+  # => {"@type"=>"Summary", "@startDate"=>"2011-09-14",
+  #     "@endDate"=>"2011-09-15", "@version"=>"1.0",
+  #     "@generatedDate"=>"9/15/117:08 AM",
+  #     "event"=>[{"@usersLastWeek"=>"164", "@usersLastMonth"=>"642", ...
+  def event_metrics query={}
+    get('eventMetrics/Summary', query)
+  end
+
+  # see: http://wiki.flurry.com/index.php?title=AppMetrics
+  # >> f.metrics('ActiveUsers', {}, :weeks => 4)
+  # => [["2011-09-16", 7929], ["2011-09-15", 36453], ["2011-09-14", 34026],
+  #     ["2011-09-13", 34245], ["2011-09-12", 36879], ["2011-09-11", 44101],
+  #     ["2011-09-10", 43362], ["2011-09-09", 36442], ...
+  def metrics path, query={}, opts={}
+    if weeks = opts.delete(:weeks)
+      query[:startDate] =
+        (Time.now + 86400 - 86400*7*weeks).strftime('%Y-%m-%d')
+    end
+
+    query[:endDate] ||= Time.now.strftime('%Y-%m-%d')
+
+    get("appMetrics/#{path}", query, opts)['day'].
+      map{ |i| [i['@date'], i['@value'].to_i] }.reverse
+  end
+
+  # >> f.weekly(f.metrics('ActiveUsers', {}, :weeks => 4))
+  # => [258213, 247935, 260418, 236995]
+  def weekly array
+    start = Time.parse(array.last.first).to_i
+    array.group_by{ |(date, value)|
+      current = Time.parse(date).to_i
+      (current - start) / (86400*7)
+    # calling .last to discard week numbers created by group_by
+    }.sort.map(&:last).map{ |week|
+      week.map{ |(date, num)| num }.inject(&:+) }
+  end
+
+  # >> f.sum(f.weekly(f.metrics('ActiveUsers', {}, :weeks => 4)))
+  # => [258213, 495870, 768771, 982343]
+  def sum array
+    array.map.with_index{ |num, index|
+      num + array[1, index].inject(0, &:+)
+    }
+  end
+
+  def query
+    {'apiKey'        => api_key    ,
+     'apiAccessCode' => access_code}
+  end
+end
+
+RestCore::Flurry.send(:include, RestCore::Flurry::Client)
+require 'rest-core/client/flurry/rails_util' if
+  Object.const_defined?(:Rails)

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

@@ -9,13 +9,10 @@ RestCore::Github = RestCore::Builder.client do
   use s::DefaultHeaders, {'Accept' => 'application/json'}
   use s::Oauth2Query   , 'access_token', nil
 
-  use s::CommonLogger  , lambda{|obj|obj}
+  use s::CommonLogger  , nil
   use s::Cache         , nil, 3600 do
-    use s::ErrorHandler , lambda{|env| raise env[s::RESPONSE_BODY]['message']}
+    use s::ErrorHandler, lambda{|env| raise env[s::RESPONSE_BODY]['message']}
     use s::ErrorDetectorHttp
-    use s::JsonDecode   , true
-    run s::Ask
+    use s::JsonDecode  , true
   end
-
-  run s::RestClient
 end

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

@@ -13,10 +13,9 @@ RestCore::Linkedin = RestCore::Builder.client(:data) do
     'uas/oauth/requestToken', 'uas/oauth/accessToken',
     'https://www.linkedin.com/uas/oauth/authorize'
 
-  use s::CommonLogger  , method(:puts)
-
+  use s::CommonLogger  , nil
   use s::Cache         , nil, 3600 do
-    use s::ErrorHandler , lambda{|env|
+    use s::ErrorHandler, lambda{|env|
       if (body = env[s::RESPONSE_BODY]).kind_of?(Hash)
         raise body['message']
       else
@@ -24,13 +23,10 @@ RestCore::Linkedin = RestCore::Builder.client(:data) do
       end
     }
     use s::ErrorDetectorHttp
-    use s::JsonDecode    , true
-    run s::Ask
+    use s::JsonDecode  , true
   end
 
   use s::Defaults      , :data     => lambda{{}}
-
-  run s::RestClient
 end
 
 module RestCore::Linkedin::Client

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

@@ -0,0 +1,51 @@
+
+RestCore::Mixi = RestCore::Builder.client(
+  :data, :consumer_key, :consumer_secret, :redirect_uri) do
+  s = self.class # this is only for ruby 1.8!
+  use s::Timeout       , 10
+
+  use s::DefaultSite   , 'http://api.mixi-platform.com/'
+  use s::DefaultHeaders, {'Accept' => 'application/json'}
+
+  use s::Oauth2Header  , nil
+
+  use s::CommonLogger  , nil
+  use s::Cache         , nil, 3600 do
+    use s::ErrorHandler  , lambda{ |env| p env }
+    use s::ErrorDetectorHttp
+    use s::JsonDecode    , true
+  end
+
+  use s::Defaults      , :data     => lambda{{}}
+end
+
+module RestCore::Mixi::Client
+  include RestCore
+
+  def access_token
+    data['access_token'] if data.kind_of?(Hash)
+  end
+
+  def authorize_url queries={}
+    url('https://mixi.jp/connect_authorize.pl',
+        {:client_id     => consumer_key,
+         :response_type => 'code',
+         :scope         => 'r_profile'}.merge(queries))
+  end
+
+  def authorize! code, payload={}, opts={}
+    pl = {:client_id     => consumer_key   ,
+          :client_secret => consumer_secret,
+          :redirect_uri  => redirect_uri   ,
+          :grant_type    => 'authorization_code',
+          :code          => code}.merge(payload)
+
+    self.data = post('https://secure.mixi-platform.com/2/token', pl, {}, opts)
+  end
+end
+
+RestCore::Mixi.send(:include, RestCore::Mixi::Client)
+
+$m = RestCore::Mixi.new(:consumer_key    => '87b9651a2291e4853ac0',
+                        :consumer_secret => '98866989c89c42e47d7d38394637faa84341ebb4',
+                        :redirect_uri => 'http://pic-collage.com')

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

@@ -0,0 +1,2 @@
+
+RestCore::Simple = RestCore::Builder.client

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

@@ -11,22 +11,18 @@ RestCore::Twitter = RestCore::Builder.client(:data) do
   use s::Oauth1Header  ,
     'oauth/request_token', 'oauth/access_token', 'oauth/authorize'
 
-  use s::CommonLogger  , lambda{|obj|obj}
-
+  use s::CommonLogger  , nil
   use s::Cache         , nil, 3600 do
-    use s::ErrorHandler  , lambda{ |env|
-                             raise ::RestCore::Twitter::Error.call(env) }
+    use s::ErrorHandler, lambda{ |env|
+                           raise ::RestCore::Twitter::Error.call(env) }
     use s::ErrorDetectorHttp
-    use s::JsonDecode    , true
-    run s::Ask
+    use s::JsonDecode  , true
   end
 
   use s::Defaults      , :data     => lambda{{}}
-
-  run s::RestClient
 end
 
-class RestCore::Twitter::Error < RuntimeError
+class RestCore::Twitter::Error < RestCore::Error
   include RestCore
   class ServerError         < Twitter::Error; end
 

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

@@ -0,0 +1,18 @@
+
+RestCore::Universal = RestCore::Builder.client(:data) do
+  s = self.class # this is only for ruby 1.8!
+  use s::Timeout       , 0
+
+  use s::DefaultSite   , nil
+  use s::DefaultHeaders, {}
+  use s::DefaultQuery  , {}
+
+  use s::CommonLogger  , method(:puts)
+  use s::Cache         , {}, 3600 do
+    use s::ErrorHandler, nil
+    use s::ErrorDetectorHttp
+    use s::JsonDecode  , false
+  end
+
+  use s::Defaults      , :data => lambda{{}}
+end

data/lib/rest-core/client.rb

@@ -48,10 +48,10 @@ module RestCore::Client
     mod.send(:include, accessor)
   end
 
-  attr_reader :app, :ask
+  attr_reader :app, :dry
   def initialize o={}
     @app ||= self.class.builder.to_app
-    @ask ||= self.class.builder.to_app(Ask)
+    @dry ||= self.class.builder.to_app(Dry)
     o.each{ |key, value| send("#{key}=", value) if respond_to?("#{key}=") }
   end
 
@@ -73,7 +73,7 @@ module RestCore::Client
                                   end
                             send("#{k}=", vv)}
     initialize(o)
-    @app, @ask = lighten_app(app), lighten_app(ask)
+    @app, @dry = lighten_app(app), lighten_app(dry)
     self
   end
 
@@ -83,10 +83,10 @@ module RestCore::Client
 
   def url path, query={}, opts={}
     Middleware.request_uri(
-      ask.call(build_env({
+      dry.call(build_env({
         REQUEST_PATH  => path,
         REQUEST_QUERY => query,
-        ASK           => true}.merge(opts))))
+        DRY           => true}.merge(opts))))
   end
 
   # extra options:
@@ -105,53 +105,54 @@ module RestCore::Client
   #       headers: Hash # additional hash you want to pass
   #                     # default: {}
   def get    path, query={}, opts={}, &cb
-    request(opts, [:get   , path, query], &cb)
+    request(
+      {REQUEST_METHOD  => :get   ,
+       REQUEST_PATH    => path   ,
+       REQUEST_QUERY   => query  }.merge(opts), &cb)
   end
 
   def delete path, query={}, opts={}, &cb
-    request(opts, [:delete, path, query], &cb)
+    request(
+      {REQUEST_METHOD  => :delete,
+       REQUEST_PATH    => path   ,
+       REQUEST_QUERY   => query  }.merge(opts), &cb)
   end
 
   def post   path, payload={}, query={}, opts={}, &cb
-    request(opts, [:post  , path, query, payload], &cb)
+    request(
+      {REQUEST_METHOD  => :post  ,
+       REQUEST_PATH    => path   ,
+       REQUEST_QUERY   => query  ,
+       REQUEST_PAYLOAD => payload}.merge(opts), &cb)
   end
 
   def put    path, payload={}, query={}, opts={}, &cb
-    request(opts, [:put   , path, query, payload], &cb)
+    request(
+      {REQUEST_METHOD  => :put   ,
+       REQUEST_PATH    => path   ,
+       REQUEST_QUERY   => query  ,
+       REQUEST_PAYLOAD => payload}.merge(opts), &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)
+  def request env, app=app
+    if block_given?
+      request_full(env, app){ |response|
+        yield(response[RESPONSE_BODY])
+      }
+    else
+      request_full(env, app)[RESPONSE_BODY]
+    end
   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]
+  def request_full env, app=app
+    response = app.call(build_env(
+      {REQUEST_METHOD  => :get,
+       REQUEST_PATH    => '/' ,
+       REQUEST_QUERY   => {}  ,
+       REQUEST_PAYLOAD => {}  ,
+       REQUEST_HEADERS => {}  ,
+       FAIL            => []  ,
+       LOG             => []  }.merge(env)))
 
     if block_given?
       yield(response)
@@ -232,47 +233,4 @@ module RestCore::Client
       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

data/lib/rest-core/error.rb

@@ -0,0 +1,5 @@
+
+module RestCore
+  class Error < RuntimeError
+  end
+end

data/lib/rest-core/middleware/bypass.rb

@@ -0,0 +1,13 @@
+
+module RestCore; end
+
+# the simplest middleware
+class RestCore::Bypass
+  def initialize app
+    @app = app
+  end
+
+  def call env
+    @app.call(env)
+  end
+end

data/lib/rest-core/middleware/common_logger.rb

@@ -16,8 +16,9 @@ class RestCore::CommonLogger
   end
 
   def flush env
-    return env if !log_method(env) || env[ASK]
-    (env[LOG] || []).each{ |obj| log_method(env).call("RestCore: #{obj}") }
+    return env if !log_method(env) || env[DRY]
+    (env[LOG] || []).compact.
+      each{ |obj| log_method(env).call("RestCore: #{obj}") }
     env.merge(LOG => [])
   end
 

data/lib/rest-core/middleware/json_decode.rb

@@ -6,6 +6,7 @@ class RestCore::JsonDecode
   include RestCore::Middleware
 
   def call env
+    return app.call(env) if env[DRY]
     response = app.call(env)
     if json_decode(env)
       response.merge(RESPONSE_BODY =>

data/lib/rest-core/middleware/oauth2_header.rb

@@ -0,0 +1,23 @@
+
+require 'rest-core/middleware'
+
+class RestCore::Oauth2Header
+  def self.members; [:access_token]; end
+  include RestCore::Middleware
+
+  def call env
+    start_time = Time.now
+    headers = {'Authorization' => "OAuth #{access_token(env)}"}.
+                merge(env[REQUEST_HEADERS] || {}) if access_token(env)
+
+    event = Event::WithHeader.new(Time.now - start_time,
+              "Authorization: #{headers['Authorization']}") if headers
+
+    app.call(log(cache_key(
+      env.merge(REQUEST_HEADERS => headers || env[REQUEST_HEADERS])), event))
+  end
+
+  def cache_key env
+    env.merge('cache.key' => "#{request_uri(env)}&#{access_token(env)}")
+  end
+end

data/lib/rest-core/middleware.rb

@@ -46,7 +46,8 @@ module RestCore::Middleware
     else
       q = if env[REQUEST_PATH] =~ /\?/ then '&' else '?' end
       "#{env[REQUEST_PATH]}#{q}" \
-      "#{query.map{ |(k, v)| "#{k}=#{CGI.escape(v.to_s)}" }.join('&')}"
+      "#{query.map{ |(k, v)|
+        "#{CGI.escape(k.to_s)}=#{CGI.escape(v.to_s)}" }.join('&')}"
     end
   end
   public :request_uri

data/lib/rest-core/test.rb

@@ -1,7 +1,5 @@
 
-require 'rest-core/client/facebook'
-
-# need to require this before webmock in order to enable mocking in em-http
+require 'rest-core'
 
 require 'rr'
 require 'webmock'

data/lib/rest-core/util/rails_util_util.rb

@@ -0,0 +1,19 @@
+
+module RestCore; end
+module RestCore::RailsUtilUtil
+  module Cache
+    def []    key       ;  read(key)                ; end
+    def []=   key, value; write(key, value)         ; end
+    def store key, value,
+              options={}; write(key, value, options); end
+  end
+
+  module_function
+  def extract_options members, options, method
+    # Hash[] is for ruby 1.8.7
+    # map(&:to_sym) is for ruby 1.8.7
+    Hash[options.send(method){ |(k, v)| members.map(&:to_sym).member?(k) }]
+  end
+end
+
+ActiveSupport::Cache::Store.send(:include, RestCore::RailsUtilUtil::Cache)

data/lib/rest-core/version.rb

@@ -1,4 +1,4 @@
 
 module RestCore
-  VERSION = '0.3.0'
+  VERSION = '0.4.0.pre.0'
 end

data/lib/rest-core/wrapper.rb

@@ -5,12 +5,18 @@ module RestCore::Wrapper
   include RestCore
   def self.included mod
     mod.send(:attr_reader, :init, :middles, :wrapped)
+    class << mod
+      attr_writer :default_app
+      def default_app
+        @default_app ||= RestCore::Dry
+      end
+    end
   end
 
   def initialize &block
     @middles ||= []
     instance_eval(&block) if block_given?
-    @wrapped ||= to_app(@init || Ask)
+    @wrapped ||= to_app
   end
 
   def use middle, *args, &block
@@ -25,14 +31,14 @@ module RestCore::Wrapper
     middles.map{ |(middle, args, block)|
       if middle.public_method_defined?(:wrapped)
         # TODO: this is hacky... try to avoid calling new!
-        middle.members + middle.new(Ask.new, *args, &block).members
+        middle.members + middle.new(Dry.new, *args, &block).members
       else
         middle.members
-      end
+      end if middle.respond_to?(:members)
     }.flatten
   end
 
-  def to_app init=@init
+  def to_app init=@init || self.class.default_app
     # === foldr m.new app middles
     middles.reverse.inject(init.new){ |app_, (middle, args, block)|
       begin

data/lib/rest-core.rb

@@ -10,13 +10,14 @@ module RestCore
   RESPONSE_STATUS  = 'RESPONSE_STATUS'
   RESPONSE_HEADERS = 'RESPONSE_HEADERS'
 
-  ASK              = 'core.ask'
+  DRY              = 'core.dry'
   FAIL             = 'core.fail'
   LOG              = 'core.log'
 
   # core utilities
   autoload :Builder       , 'rest-core/builder'
   autoload :Client        , 'rest-core/client'
+  autoload :Error         , 'rest-core/error'
   autoload :Event         , 'rest-core/event'
   autoload :Middleware    , 'rest-core/middleware'
   autoload :Wrapper       , 'rest-core/wrapper'
@@ -30,6 +31,7 @@ module RestCore
   autoload :Vendor        , 'rest-core/util/vendor'
 
   # middlewares
+  autoload :Bypass        , 'rest-core/middleware/bypass'
   autoload :Cache         , 'rest-core/middleware/cache'
   autoload :CommonLogger  , 'rest-core/middleware/common_logger'
   autoload :DefaultHeaders, 'rest-core/middleware/default_headers'
@@ -41,18 +43,23 @@ module RestCore
   autoload :ErrorHandler  , 'rest-core/middleware/error_handler'
   autoload :JsonDecode    , 'rest-core/middleware/json_decode'
   autoload :Oauth1Header  , 'rest-core/middleware/oauth1_header'
+  autoload :Oauth2Header  , 'rest-core/middleware/oauth2_header'
   autoload :Oauth2Query   , 'rest-core/middleware/oauth2_query'
   autoload :Timeout       , 'rest-core/middleware/timeout'
 
   # apps
-  autoload :Ask           , 'rest-core/app/ask'
+  autoload :Dry           , 'rest-core/app/dry'
   autoload :RestClient    , 'rest-core/app/rest-client'
 
   # clients
+  autoload :Simple        , 'rest-core/client/simple'
   autoload :Github        , 'rest-core/client/github'
   autoload :Twitter       , 'rest-core/client/twitter'
   autoload :Linkedin      , 'rest-core/client/linkedin'
   autoload :Facebook      , 'rest-core/client/facebook'
+  autoload :Mixi          , 'rest-core/client/mixi'
+  autoload :Universal     , 'rest-core/client/universal'
+  autoload :Flurry        , 'rest-core/client/flurry'
 end
 
 RC = RestCore unless Object.const_defined?(:RC)

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

@@ -0,0 +1,15 @@
+
+require 'rest-core'
+
+module Rib; end
+module Rib::RestCore
+  Rib::Shell.use(self)
+  def self.load
+    Rib.shell.config[:binding] =
+      ::RestCore::Universal.new.instance_eval{binding}
+  end
+
+  def prompt
+    "rest-core#{super}"
+  end
+end