rest-more 0.7.0

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

@@ -0,0 +1,107 @@
+
+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::Timeout       , 10
+
+  use s::DefaultSite   , 'http://api.flurry.com/'
+  use s::DefaultHeaders, {'Accept' => 'application/json'}
+  use s::DefaultQuery  , {}
+
+  use s::CommonLogger  , nil
+  use s::Cache         , nil, 600 do
+    use s::ErrorHandler, lambda{|env| raise env[s::RESPONSE_BODY]['message']}
+    use s::ErrorDetectorHttp
+    use s::JsonDecode  , true
+  end
+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({}, :days => 7)
+  # => {"Facebook share error"=>{"@usersLastWeek"=>"948",
+  #                              "@usersLastMonth"=>"2046",
+  #                              "@usersLastDay"=>"4",...}}
+  def event_metrics query={}, opts={}
+    get('eventMetrics/Summary', *calculate_query_and_opts(query, opts)
+      )['event'].inject({}){ |r, i|
+        r[i['@eventName']] = i.reject{ |k, _| k == '@eventName' }
+        r }
+  end
+
+  # see: http://wiki.flurry.com/index.php?title=AppMetrics
+  # >> f.metrics('ActiveUsers', {}, :weeks => 4)
+  # => [["2011-09-19",  6516], ["2011-09-18", 43920], ["2011-09-17", 45412],
+  #     ["2011-09-16", 40972], ["2011-09-15", 37587], ["2011-09-14", 34918],
+  #     ["2011-09-13", 35223], ["2011-09-12", 37750], ["2011-09-11", 45057],
+  #     ["2011-09-10", 44077], ["2011-09-09", 36683], ["2011-09-08", 34871],
+  #     ["2011-09-07", 35960], ["2011-09-06", 35829], ["2011-09-05", 37777],
+  #     ["2011-09-04", 40233], ["2011-09-03", 39306], ["2011-09-02", 33467],
+  #     ["2011-09-01", 31558], ["2011-08-31", 32096], ["2011-08-30", 34076],
+  #     ["2011-08-29", 34950], ["2011-08-28", 40456], ["2011-08-27", 41332],
+  #     ["2011-08-26", 37737], ["2011-08-25", 34392], ["2011-08-24", 33560],
+  #     ["2011-08-23", 34722]]
+  def metrics path, query={}, opts={}
+    get("appMetrics/#{path}", *calculate_query_and_opts(query, opts)
+      )['day'].map{ |i| [i['@date'], i['@value'].to_i] }.reverse
+  end
+
+  # >> f.weekly(f.metrics('ActiveUsers', {}, :weeks => 4))
+  # => [244548, 270227, 248513, 257149]
+  def weekly array
+    start = Time.parse(array.first.first, nil).to_i
+    array.group_by{ |(date, value)|
+      current = Time.parse(date, nil).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)))
+  # => [1020437, 775889, 505662, 257149]
+  def sum array
+    reverse = array.reverse
+    (0...reverse.size).map{ |index|
+      reverse[1, index].inject(reverse.first, &:+)
+    }.reverse
+  end
+
+  def query
+    {'apiKey'        => api_key    ,
+     'apiAccessCode' => access_code}
+  end
+
+  private
+  def calculate_query_and_opts query, opts
+    days = opts[:days] || (opts[:weeks]  && opts[:weeks] * 7)   ||
+                          (opts[:months] && opts[:months] * 30)
+
+    startDate = query[:startDate] || (Time.now + 86400 - 86400*days).
+      strftime('%Y-%m-%d')
+
+    endDate   = query[:endDate]   || Time.now.
+      strftime('%Y-%m-%d')
+
+    [query.merge(:startDate => startDate,
+                 :endDate   => endDate),
+     opts.reject{ |k| [:days, :weeks, :months].include?(k) }]
+  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/flurry/rails_util.rb

@@ -0,0 +1,74 @@
+
+require 'rest-core/util/rails_util_util'
+
+module RestCore::Flurry::DefaultAttributes
+  def default_log_method ; Rails.logger.method(:debug); end
+  def default_cache      ; Rails.cache                ; end
+  def default_api_key    ; nil                        ; end
+  def default_access_code; nil                        ; end
+end
+
+module RestCore::Flurry::RailsUtil
+  def self.init app=Rails
+    RestCore::Config.load_for_rails(RestCore::Flurry, 'flurry', app)
+  end
+
+  module Helper
+    def rc_flurry
+      controller.send(:rc_flurry)
+    end
+  end
+
+  def self.included controller
+    # skip if included already, any better way to detect this?
+    return if controller.respond_to?(:rc_flurry, true)
+
+    controller.helper(RestCore::Flurry::RailsUtil::Helper)
+    controller.instance_methods.select{ |method|
+      method.to_s =~ /^rc_flurry/
+    }.each{ |method| controller.send(:protected, method) }
+  end
+
+  def rc_flurry_setup options={}
+    rc_flurry_options_ctl.merge!(
+      RestCore::RailsUtilUtil.extract_options(
+        RestCore::Flurry.members, options, :reject))
+    rc_flurry_options_new.merge!(
+      RestCore::RailsUtilUtil.extract_options(
+        RestCore::Flurry.members, options, :select))
+
+    # we'll need to reinitialize rc_flurry with the new options,
+    # otherwise if you're calling rc_flurry before rc_flurry_setup,
+    # you'll end up with default options without the ones you've passed
+    # into rc_flurry_setup.
+    rc_flurry.send(:initialize, rc_flurry_options_new)
+
+    true # keep going
+  end
+
+  def rc_flurry
+    @rc_flurry ||= RestCore::Flurry.new(rc_flurry_options_new)
+  end
+
+  module_function
+
+  # ==================== begin options utility =======================
+  def rc_flurry_oget key
+    if rc_flurry_options_ctl.has_key?(key)
+      rc_flurry_options_ctl[key]
+    else
+      RestCore::Flurry.send("default_#{key}")
+    end
+  end
+
+  def rc_flurry_options_ctl
+    @rc_flurry_options_ctl ||= {}
+  end
+
+  def rc_flurry_options_new
+    @rc_flurry_options_new ||= {}
+  end
+  # ==================== end options utility =======================
+end
+
+RestCore::Flurry::RailsUtil.init(Rails)

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

@@ -0,0 +1,18 @@
+
+require 'rest-core'
+
+RestCore::Github = RestCore::Builder.client 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  , nil
+  use s::Cache         , nil, 600 do
+    use s::ErrorHandler, lambda{|env| raise env[s::RESPONSE_BODY]['message']}
+    use s::ErrorDetectorHttp
+    use s::JsonDecode  , true
+  end
+end

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

@@ -0,0 +1,59 @@
+
+require 'rest-core'
+
+RestCore::Linkedin = RestCore::Builder.client(: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  , nil
+  use s::Cache         , nil, 600 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
+  end
+
+  use s::Defaults      , :data     => lambda{{}}
+end
+
+module RestCore::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
+
+  def me queries={}, opts={}
+    get('v1/people/~', queries, opts)
+  end
+
+  private
+  def set_token query
+    self.data = query
+  end
+end
+
+RestCore::Linkedin.send(:include, RestCore::ClientOauth1)
+RestCore::Linkedin.send(:include, RestCore::Linkedin::Client)

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

@@ -0,0 +1,47 @@
+
+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, 600 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)

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

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

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

@@ -0,0 +1,101 @@
+
+require 'rest-core'
+
+RestCore::Twitter = RestCore::Builder.client(: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  , nil
+  use s::Cache         , nil, 600 do
+    use s::ErrorHandler, lambda{ |env|
+                           raise ::RestCore::Twitter::Error.call(env) }
+    use s::ErrorDetectorHttp
+    use s::JsonDecode  , true
+  end
+
+  use s::Defaults      , :data     => lambda{{}}
+end
+
+class RestCore::Twitter::Error < RestCore::Error
+  include RestCore
+  class ServerError         < Twitter::Error; end
+
+  class BadRequest          < Twitter::Error; end
+  class Unauthorized        < Twitter::Error; end
+  class Forbidden           < Twitter::Error; end
+  class NotFound            < Twitter::Error; end
+  class NotAcceptable       < Twitter::Error; end
+  class EnhanceYourCalm     < Twitter::Error; end
+
+  class InternalServerError < Twitter::Error::ServerError; end
+  class BadGateway          < Twitter::Error::ServerError; end
+  class ServiceUnavailable  < Twitter::Error::ServerError; 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)
+    case env[RESPONSE_STATUS]
+      when 400; BadRequest
+      when 401; Unauthorized
+      when 403; Forbidden
+      when 404; NotFound
+      when 406; NotAcceptable
+      when 420; EnhanceYourCalm
+      when 500; InternalServerError
+      when 502; BadGateway
+      when 503; ServiceUnavailable
+      else    ; self
+    end.new(error, url)
+  end
+end
+
+module RestCore::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, media=nil, opts={}
+    if media
+      post('https://upload.twitter.com/1/statuses/update_with_media.json',
+        {:status => status, 'media[]' => media},
+        {}, opts)
+    else
+      post('1/statuses/update.json', {:status => status}, {}, opts)
+    end
+  end
+
+  def statuses user, queries={}, opts={}
+    get('1/statuses/user_timeline.json', {:id => user}.merge(queries), opts)
+  end
+
+  private
+  def set_token query
+    self.data = query
+  end
+end
+
+RestCore::Twitter.send(:include, RestCore::ClientOauth1)
+RestCore::Twitter.send(:include, RestCore::Twitter::Client)

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         , {}, 600 do
+    use s::ErrorHandler, nil
+    use s::ErrorDetectorHttp
+    use s::JsonDecode  , false
+  end
+
+  use s::Defaults      , :data => lambda{{}}
+end

data/lib/rest-more.rb

@@ -0,0 +1,11 @@
+
+require 'rest-core'
+
+module RestCore
+  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 :Flurry  , 'rest-core/client/flurry'
+end