rest-core 0.0.1

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

@@ -0,0 +1,80 @@
+
+require 'rest-core/event'
+require 'rest-core/middleware'
+require 'rest-core/wrapper'
+
+require 'digest/md5'
+
+class RestCore::Cache
+  def self.members; [:cache, :expires_in]; end
+  include RestCore::Middleware
+  include RestCore::Wrapper
+
+  def initialize app, cache, expires_in, &block
+    super(&block)
+    @app, @cache, @expires_in = app, cache, expires_in
+  end
+
+  def call env
+    e = if env['cache.update'] && env[REQUEST_METHOD] == :get
+          cache_assign(env, nil)
+        else
+          env
+        end
+
+    if cached = cache_get(e)
+      wrapped.call(cached)
+    else
+      response         = app.call(e)
+      response_wrapped = wrapped.call(response)
+      if (response_wrapped[FAIL] || []).empty?
+        cache_for(e, response).merge(response_wrapped)
+      else
+        response_wrapped
+      end
+    end
+  end
+
+  protected
+  def cache_key env
+    Digest::MD5.hexdigest(env['cache.key'] || request_uri(env))
+  end
+
+  def cache_get env
+    return unless cache(env)
+    start_time = Time.now
+    return unless value = cache(env)[cache_key(env)]
+    log(env, Event::CacheHit.new(Time.now - start_time, request_uri(env))).
+      merge(RESPONSE_BODY => value)
+  end
+
+  def cache_for env, response
+    return response unless cache(env)
+    # fake post (env['cache.post'] => true) is considered get and need cache
+    return response if env[REQUEST_METHOD] != :get unless env['cache.post']
+
+    value = response[RESPONSE_BODY]
+
+    if expires_in(env).kind_of?(Fixnum) &&
+       cache(env).method(:store).arity == -3
+      cache(env).store(cache_key(env), value,
+                       :expires_in => expires_in(env))
+      response
+    else
+      cache_assign(response, value)
+    end
+  end
+
+  def cache_assign env, value
+    return env unless cache(env)
+
+    start_time = Time.now
+    cache(env)[cache_key(env)] = value
+    if value.nil?
+      log(env,
+        Event::CacheCleared.new(Time.now - start_time, request_uri(env)))
+    else
+      env
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+
+require 'rest-core/event'
+require 'rest-core/middleware'
+
+class RestCore::CommonLogger
+  def self.members; [:log_method]; end
+  include RestCore::Middleware
+
+  def call env
+    start_time = Time.now
+    response = app.call(flushed = flush(env))
+    flush(log(response, log_request(start_time, response)))
+  rescue
+    flush(log(flushed, log_request(start_time, flushed)))
+    raise
+  end
+
+  def flush env
+    return env if !log_method(env) || env[ASK]
+    (env[LOG] || []).each{ |obj| log_method(env).call("RestCore: #{obj}") }
+    env.merge(LOG => [])
+  end
+
+  def log_request start_time, response
+    Event::Requested.new(Time.now - start_time, request_uri(response))
+  end
+end

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

@@ -0,0 +1,11 @@
+
+require 'rest-core/middleware'
+
+class RestCore::DefaultHeaders
+  def self.members; [:headers]; end
+  include RestCore::Middleware
+  def call env
+    app.call(env.merge(REQUEST_HEADERS =>
+      @headers.merge(headers(env)).merge(env[REQUEST_HEADERS] || {})))
+  end
+end

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

@@ -0,0 +1,11 @@
+
+require 'rest-core/middleware'
+
+class RestCore::DefaultQuery
+  def self.members; [:query]; end
+  include RestCore::Middleware
+  def call env
+    app.call(env.merge(REQUEST_QUERY =>
+      @query.merge(query(env)).merge(env[REQUEST_QUERY] || {})))
+  end
+end

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

@@ -0,0 +1,15 @@
+
+require 'rest-core/middleware'
+
+class RestCore::DefaultSite
+  def self.members; [:site]; end
+  include RestCore::Middleware
+
+  def call env
+    if env[REQUEST_PATH].to_s.start_with?('http')
+      app.call(env)
+    else
+      app.call(env.merge(REQUEST_PATH => "#{site(env)}#{env[REQUEST_PATH]}"))
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+
+require 'rest-core/middleware'
+
+class RestCore::Defaults
+  def self.members; [:defaults]; end
+  include RestCore::Middleware
+
+  # the use of singleton_class is making serialization hard!
+  # def initialize app, defaults
+  #   super
+  #   singleton_class.module_eval do
+  #     defaults.each{ |(key, value)|
+  #       define_method(key) do |env|
+  #         if value.respond_to?(:call)
+  #           value.call
+  #         else
+  #           value
+  #         end
+  #       end
+  #     }
+  #   end
+  # end
+
+  def method_missing msg, *args, &block
+    env = args.first
+    if env.kind_of?(Hash) && (d = defaults(env)) && d.key?(msg)
+      if (value = defaults(env)[msg]).respond_to?(:call)
+        value.call
+      else
+        value
+      end
+    else
+      super
+    end
+  end
+
+  def respond_to? msg
+    if (d = defaults({})) && d.key?(msg)
+      true
+    else
+      super
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+
+require 'rest-core/middleware'
+
+class RestCore::ErrorDetector
+  def self.members; [:error_detector]; end
+  include RestCore::Middleware
+
+  def call env
+    response = app.call(env)
+    if error = error_detector(env).call(response)
+      fail(response, error)
+    else
+      response
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+
+require 'rest-core/middleware/error_detector'
+
+class RestCore::ErrorDetectorHttp < RestCore::ErrorDetector
+  def self.members; [:error_detector]; end
+  include RestCore::Middleware
+
+  def initialize app
+    super(app, lambda{ |env| (env[RESPONSE_STATUS] || 200) / 100 != 2 })
+  end
+end

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

@@ -0,0 +1,19 @@
+
+require 'rest-core/middleware'
+
+class RestCore::ErrorHandler
+  def self.members; [:error_handler]; end
+  include RestCore::Middleware
+
+  def call env
+    handle(app.call(handle(env)))
+  end
+
+  def handle env
+    if error_handler(env) && !(env[FAIL] || []).empty?
+      error_handler(env).call(env)
+    else
+      env
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+
+require 'rest-core/middleware'
+
+class RestCore::JsonDecode
+  def self.members; [:json_decode]; end
+  include RestCore::Middleware
+
+  def call env
+    response = app.call(env)
+    if json_decode(env)
+      response.merge(RESPONSE_BODY =>
+        self.class.json_decode("[#{response[RESPONSE_BODY]}]").first)
+        # [this].first is not needed for yajl-ruby
+    else
+      response
+    end
+  rescue self.class.const_get(:ParseError) => error
+    fail(response, error)
+  end
+
+  module YajlRuby
+    def self.extended mod
+      mod.const_set(:ParseError, Yajl::ParseError)
+    end
+    def json_encode hash
+      Yajl::Encoder.encode(hash)
+    end
+    def json_decode json
+      Yajl::Parser.parse(json)
+    end
+  end
+
+  module Json
+    def self.extended mod
+      mod.const_set(:ParseError, JSON::ParserError)
+    end
+    def json_encode hash
+      JSON.dump(hash)
+    end
+    def json_decode json
+      JSON.parse(json)
+    end
+  end
+
+  module Gsub
+    class ParseError < RuntimeError; end
+    def self.extended mod
+      mod.const_set(:ParseError, Gsub::ParseError)
+    end
+    # only works for flat hash
+    def json_encode hash
+      middle = hash.inject([]){ |r, (k, v)|
+                 r << "\"#{k}\":\"#{v.gsub('"','\\"')}\""
+               }.join(',')
+      "{#{middle}}"
+    end
+    def json_decode json
+      raise NotImplementedError.new(
+        'You need to install either yajl-ruby, json, or json_pure gem')
+    end
+  end
+
+  def self.select_json! mod, picked=false
+    if    Object.const_defined?(:Yajl)
+      mod.send(:extend, YajlRuby)
+    elsif Object.const_defined?(:JSON)
+      mod.send(:extend, Json)
+    elsif picked
+      mod.send(:extend, Gsub)
+    else
+      # pick a json gem if available
+      %w[yajl json].each{ |json|
+        begin
+          require json
+          break
+        rescue LoadError
+        end
+      }
+      select_json!(mod, true)
+    end
+  end
+  select_json!(self)
+end

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

@@ -0,0 +1,81 @@
+
+require 'rest-core/middleware'
+require 'rest-core/util/hmac'
+
+require 'uri'
+require 'openssl'
+
+class RestCore::Oauth1Header
+  def self.members
+    [:request_token_path, :access_token_path, :authorize_path,
+     :consumer_key, :consumer_secret,
+     :callback, :verifier, :oauth_token, :oauth_token_secret]
+  end
+  include RestCore::Middleware
+  def call env
+    start_time = Time.now
+    headers = {'Authorization' => oauth_header(env)}.
+                merge(env[REQUEST_HEADERS] || {})
+
+    event = Event::WithHeader.new(Time.now - start_time,
+              "Authorization: #{headers['Authorization']}")
+
+    app.call(log(cache_key(env.merge(REQUEST_HEADERS => headers)), event))
+  end
+
+  def cache_key env
+    env.merge('cache.key' =>
+      "#{request_uri(env)}&#{oauth_token(env)}&#{oauth_token_secret(env)}")
+  end
+
+  def oauth_header env
+    header = attach_signature(env,
+      'oauth_consumer_key'     => consumer_key(env),
+      'oauth_signature_method' => 'HMAC-SHA1',
+      'oauth_timestamp'        => Time.now.to_i.to_s,
+      'oauth_nonce'            => nonce,
+      'oauth_version'          => '1.0',
+      'oauth_callback'         => callback(env),
+      'oauth_verifier'         => verifier(env),
+      'oauth_token'            => oauth_token(env))
+
+    "OAuth #{header.map{ |(k, v)| "#{k}=\"#{v}\"" }.join(', ')}"
+  end
+
+  def attach_signature env, oauth_params
+    params = reject_blank(oauth_params)
+    params.merge('oauth_signature' => encode(signature(env, params)))
+  end
+
+  def signature env, params
+    [Hmac.sha1("#{consumer_secret(env)}&#{oauth_token_secret(env)}",
+               base_string(env, params))].pack('m').tr("\n", '')
+  end
+
+  def base_string env, oauth_params
+    method   = env[REQUEST_METHOD].to_s.upcase
+    base_uri = env[REQUEST_PATH]
+    query    = reject_blank(env[REQUEST_QUERY]   || {})
+    payload  = reject_blank(env[REQUEST_PAYLOAD] || {})
+    params   = reject_blank(oauth_params.merge(query.merge(payload))).
+      to_a.sort.map{ |(k, v)|
+        "#{encode(k.to_s)}=#{encode(v.to_s)}"}.join('&')
+
+    "#{method}&#{encode(base_uri)}&#{encode(params)}"
+  end
+
+  def nonce
+    [OpenSSL::Random.random_bytes(32)].pack('m').tr("+/=\n", '')
+  end
+
+  def reject_blank params
+    params.reject{ |k, v| v.nil? || v == false ||
+                                    (v.respond_to?(:strip) &&
+                                     v.respond_to?(:empty) &&
+                                     v.strip.empty? == true) }
+  end
+
+  def encode string
+    URI.encode(string, /[^a-zA-Z0-9\-\.\_\~]/)
+  end
+end

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

@@ -0,0 +1,19 @@
+
+require 'rest-core/middleware'
+
+class RestCore::Oauth2Query
+  def self.members; [:oauth_token_name, :oauth_token]; end
+  include RestCore::Middleware
+
+  def call env
+    local = if oauth_token(env)
+              env.merge(REQUEST_QUERY =>
+                          {oauth_token_name(env) => oauth_token(env)}.
+                           merge(env[REQUEST_QUERY] || {}))
+            else
+              env
+            end
+
+    app.call(local)
+  end
+end

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

@@ -0,0 +1,13 @@
+
+require 'rest-core/middleware'
+
+require 'timeout'
+
+class RestCore::Timeout
+  def self.members; [:timeout]; end
+  include RestCore::Middleware
+
+  def call env
+    ::Timeout.timeout(timeout(env)){ app.call(env) }
+  end
+end