rocketio 0.0.0.pre.alpha → 0.0.0

data/lib/rocketio/controller/authorization.rb

@@ -1,53 +0,0 @@
-require 'rocketio/controller/token_auth'
-
-module RocketIO
-  class Controller
-
-    # easily restrict access to controller using token auth
-    #
-    # @example simple Token example
-    #
-    #   class User < RocketIO::Controller
-    #     token_auth { |token| token == 'secret' }
-    #   end
-    #
-    def self.token_auth *args, &block
-      opts = args.last.is_a?(Hash) ? args.pop : {}
-      (args.any? ? args.map!(&:to_sym) : RocketIO::REQUEST_METHODS.values).each do |rm|
-        (@__token_auth__ ||= {})[rm] = {
-          realm: opts[:realm] || RocketIO::DEFAULT_TOKEN_AUTH_REALM.freeze,
-          block: block
-        }
-      end
-      define_token_auth_methods
-    end
-
-    def self.define_token_auth_methods source = self
-      prompts = allocate.token_auth.merge(source.instance_variable_get(:@__token_auth__) || {}).freeze
-      return if prompts.empty?
-      define_method(:token_auth) {prompts}
-    end
-
-    def token_auth; RocketIO::EMPTY_HASH end
-
-    def validate_or_request_authorization_if_needed
-      return unless auth = token_auth[requested_method]
-      return if validate_token_auth(&auth[:block])
-      throw(:__response__, request_token_auth(auth[:realm]))
-    end
-
-    def validate_or_request_token_auth realm = RocketIO::DEFAULT_TOKEN_AUTH_REALM, &block
-      validate_token_auth(&block) || request_token_auth(realm)
-    end
-
-    def validate_token_auth &block
-      RocketIO::TokenAuth.authenticate(env, &block)
-    end
-    alias valid_token_auth? validate_token_auth
-
-    def request_token_auth realm = RocketIO::DEFAULT_TOKEN_AUTH_REALM
-      RocketIO::TokenAuth.authentication_request(realm)
-    end
-    alias request_token_auth! request_token_auth
-  end
-end

data/lib/rocketio/controller/cookies.rb

@@ -1,59 +0,0 @@
-module RocketIO
-  class Controller
-
-    # shorthand for `request.cookies`, `response.set_cookie` and `response.delete_cookie`
-    #
-    # @example Setting a cookie
-    #   cookies['cookie-name'] = 'value'
-    #
-    # @example Reading a cookie
-    #   cookies['cookie-name']
-    #
-    # @example Setting a cookie with custom options
-    #   cookies['question_of_the_day'] = {
-    #     value: 'who is not who?',
-    #     expires: Date.today + 1,
-    #     secure: true
-    #   }
-    #
-    # @example Deleting a cookie
-    #   cookies.delete('cookie-name')
-    #
-    def cookies
-      @__cookies__ ||= RocketIO::Cookies.new(request.cookies, response)
-    end
-  end
-end
-
-module RocketIO
-  class Cookies
-
-    def initialize cookies, response
-      @cookies  = RocketIO.indifferent_params(cookies)
-      @response = response
-    end
-
-    # set cookie header
-    #
-    # @param [String, Symbol] key
-    # @param [String, Hash] val
-    #
-    def []= key, val
-      @response.set_cookie(key, val)
-    end
-
-    # get cookie by key
-    def [] key
-      @cookies[key]
-    end
-
-    # instruct browser to delete a cookie
-    #
-    # @param [String, Symbol] key
-    # @param [Hash] opts
-    #
-    def delete key, opts ={}
-      @response.delete_cookie(key, opts)
-    end
-  end
-end

data/lib/rocketio/controller/error_handlers.rb

@@ -1,89 +0,0 @@
-module RocketIO
-  class Controller
-
-    # define error handlers
-    #
-    # @example define a handler that will process 404 errors
-    #   class Pages < RocketIO::Controller
-    #
-    #     error 404 do |id|
-    #       "Sorry, looks like item with ID #{id.to_i} does not exists"
-    #     end
-    #
-    #     def get id
-    #       item = Item.find_by(id: id) || error(404, id)
-    #     end
-    #   end
-    #
-    # @example define a handler that will process fatal errors
-    #   class Pages < RocketIO::Controller
-    #
-    #     error 500 do |exception|
-    #       "Fatal error occurred: " + html_escape(exception.message)
-    #     end
-    #
-    #     def get
-    #       # any exception raised here will be handled by the handler above
-    #     end
-    #   end
-    #
-    def self.error code, &block
-      code = code.to_i
-      code > 0 || raise(ArgumentError, 'Error code should be a number')
-      block || raise(ArgumentError, 'block missing')
-      (@__error_handlers__ ||= {})[code] = block
-      define_error_handlers_methods
-    end
-
-    def self.define_error_handlers_methods source = self
-      handlers = (source.instance_variable_get(:@__error_handlers__) || {}).each_with_object({}) do |(code,proc),o|
-        o[code] = :"__#{code}_error_handler__"
-        define_method(o[code], &proc)
-      end
-      handlers.update(allocate.error_handlers)
-      return if handlers.empty?
-      handlers.freeze
-      define_method(:error_handlers) {handlers}
-    end
-
-    def error_handlers; RocketIO::EMPTY_HASH end
-
-    # if there is a handler defined for given code it will be executed and the result used as body.
-    # otherwise the `error` behaves exactly as `halt`.
-    #
-    # given args will be passed either to handler(if any defined) or to `halt`
-    #
-    def error code, *args
-      error_handlers[code] || halt(code, *args)
-      halt(code, __send__(error_handlers[code], *args))
-    end
-    alias error! error
-
-    # 404: Not Found
-    error 404 do
-      RocketIO.error_renderer(404, xhr?, env: env)
-    end
-
-    # 409: Wrong number of arguments received
-    error 409 do
-      RocketIO.error_renderer(409, xhr?, {
-        env: env,
-        controller: self.class,
-        resolved_path: url,
-        expected_parameters: parameters_policy[env[RocketIO::REQUEST_METHOD]],
-        received_parameters: path_params
-      })
-    end
-
-    # 500: Fatal Error
-    error 500 do |error|
-      error = StandardError.new(error) unless Exception === error
-      RocketIO.error_renderer(500, xhr?, env: env, error: error)
-    end
-
-    # 501: Not Implemented
-    error 501 do
-      RocketIO.error_renderer(501, xhr?, env: env)
-    end
-  end
-end

data/lib/rocketio/controller/filters.rb

@@ -1,119 +0,0 @@
-module RocketIO
-  class Controller
-
-    # define blocks to run before, around, after called method.
-    # if no methods given, given block will run on any called method.
-    #
-    # @note call it without a block to define a void filter.
-    #       useful to override inherited filters.
-    #
-    # @note sub-controllers will inherit all filters from parent controller
-    #       and can override them selectively, by name
-    #
-    # @note wildcard filters will run before/around/after any methods,
-    #       that's it, if defining `before {}` and `before(:get) {}` filters
-    #       `get` method will run `before` filter then `before(:get)`
-    #
-    # @example run before any requested method, being it REST or websocket
-    #   before do
-    #     # some logic here
-    #   end
-    #
-    # @example run only before GET
-    #   before :get do
-    #     # some logic here
-    #   end
-    #
-    # @example run only around PUT and POST
-    #   around :put, :post do |app|
-    #     # some logic here
-    #     app.call
-    #   end
-    #
-    # @example run only after :register websocket call
-    #   after :register do
-    #     # some logic here
-    #   end
-    #
-    # @example define a filter that does nothing. useful to override inherited filters.
-    #   before :get
-    #
-    # @example run 2 blocks before GET
-    #   before do  # wildcard filter, will run before any method
-    #     @user = User.find...
-    #   end
-    #
-    #   before :get do  # named filter, will run only before `get`
-    #     # wildcard filter already executed so we have `@user` variable here
-    #     @photo = @user.photos.find...
-    #   end
-    #
-    #   # before calling `get` two filters will be executed:
-    #   # - wildcard one
-    #   # - named one
-    #   def get
-    #     # both @user and @photo variables available here
-    #   end
-    #
-    {
-      before: proc {},
-      around: proc {|app| app.call},
-      after:  proc {}
-    }.each_pair do |filter,default_block|
-      define_methods = :"define_#{filter}_methods"
-      var = :"@__#{filter}_filters__"
-
-      define_singleton_method filter do |*methods,&block|
-        instance_variable_get(var) || instance_variable_set(var, {})
-        methods = [:*] if methods.empty?
-        methods.each do |meth|
-          instance_variable_get(var)[meth.to_sym] = block || default_block
-        end
-        __send__(define_methods)
-      end
-
-      define_singleton_method define_methods do |source = self|
-        filters = (source.instance_variable_get(var) || {}).each_with_object({}) do |(meth,proc),o|
-          o[meth] = :"__#{filter}_#{meth}__"
-          define_method(o[meth], &proc)
-        end
-        filters.update(allocate.__send__(filter))
-        return unless filters.any?
-        filters.freeze
-        define_method(filter) {filters}
-      end
-    end
-
-    def before; RocketIO::EMPTY_HASH end
-    def around; RocketIO::EMPTY_HASH end
-    def after;  RocketIO::EMPTY_HASH end
-
-    def invoke_before_filter method = requested_method
-      __send__(before[:*]) if before[:*]
-      __send__(before[method]) if before[method]
-    end
-
-    # passing blocks somehow tends to add some overhead
-    # so passing the proc as a common argument
-    def invoke_around_filter method = requested_method, block
-      if around[:*]
-        __send__ around[:*], proc {
-          if around[method]
-            __send__(around[method], block)
-          else
-            block.call
-          end
-        }
-      elsif around[method]
-        __send__(around[method], block)
-      else
-        block.call
-      end
-    end
-
-    def invoke_after_filter method = requested_method
-      __send__(after[:*]) if after[:*]
-      __send__(after[method]) if after[method]
-    end
-  end
-end

data/lib/rocketio/controller/flash.rb

@@ -1,21 +0,0 @@
-module RocketIO
-  class Flash
-    KEY_FORMAT = '__session__flash__%s'.freeze
-
-    def initialize session = {}
-      @session = session
-    end
-
-    def []= key, val
-      @session[key(key)] = val
-    end
-
-    def [] key
-      @session.delete(key(key))
-    end
-
-    def key key
-      KEY_FORMAT % key.to_s
-    end
-  end
-end

data/lib/rocketio/controller/helpers.rb

@@ -1,438 +0,0 @@
-# Copyright (c) 2007, 2008, 2009 Blake Mizerany
-# Copyright (c) 2010, 2011, 2012, 2013, 2014 Konstantin Haase
-# Copyright (c) 2015 Slee Woo
-#
-# Permission is hereby granted, free of charge, to any person
-# obtaining a copy of this software and associated documentation
-# files (the "Software"), to deal in the Software without
-# restriction, including without limitation the rights to use,
-# copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the
-# Software is furnished to do so, subject to the following
-# conditions:
-#
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-# OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-# HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-# OTHER DEALINGS IN THE SOFTWARE.
-
-module RocketIO
-  class Controller
-
-    # helpers to determine actual request method
-    # `get?` returns true for GET, `post?` for POST etc.
-    RocketIO::REQUEST_METHODS.each_key do |request_method|
-      define_method request_method.downcase + '?' do
-        env[RocketIO::REQUEST_METHOD] == request_method
-      end
-    end
-
-    # whether or not the status is set to 1xx
-    def informational?
-      response.status.between? 100, 199
-    end
-
-    # whether or not the status is set to 2xx
-    def success?
-      response.status.between? 200, 299
-    end
-
-    # whether or not the status is set to 3xx
-    def redirect?
-      response.status.between? 300, 399
-    end
-
-    # whether or not the status is set to 4xx
-    def client_error?
-      response.status.between? 400, 499
-    end
-
-    # whether or not the status is set to 5xx
-    def server_error?
-      response.status.between? 500, 599
-    end
-
-    # whether or not the status is set to 404
-    def not_found?
-      response.status == 404
-    end
-
-    # returns true for HTTP/1.1 requests
-    def http_1_1?
-      env[RocketIO::HTTP_VERSION] == RocketIO::HTTP_1_1
-    end
-
-    def xhr?
-      env[RocketIO::HTTP_X_REQUESTED_WITH] == RocketIO::XML_HTTP_REQUEST
-    end
-
-    # switch controller and halt with returned response.
-    # any arguments will be passed to requested method.
-    #
-    # @example pass control to User controller, call requested method without arguments
-    #   pass User
-    #
-    # @example pass control to User controller, call requested method with [:bob, :bobsen] arguments
-    #   pass User, :bob, :bobsen
-    #
-    def pass controller, *args
-      halt controller.initialize_controller(RocketIO::REQUEST_METHODS[request_method], args).call(env)
-    end
-
-    # stop executing any code and send response to browser.
-    #
-    # accepts an arbitrary number of arguments.
-    # if first argument is a Rack::Response,
-    # halting right away using the first arg as response and ignore other args.
-    #
-    # if first arg is a Array, updating current response
-    # using first array element as status, second to update headers and 3rd as body
-    #
-    # if some arg is an Integer, it will be used as status code.
-    # if some arg is a Hash, it is treated as headers.
-    # any other args are treated as body.
-    #
-    # if no args given it halts with current response.
-    #
-    # @example returning "Well Done" body with 200 status code
-    #    halt 'Well Done'
-    #
-    # @example halting with current response without alter it in any way
-    #    halt
-    #
-    # @example returning a error message with 500 code:
-    #    halt 500, 'Sorry, some fatal error occurred'
-    #
-    # @example custom content type
-    #    halt File.read('/path/to/theme.css'), 'Content-Type' => mime_type('.css')
-    #
-    # @example sending custom Rack response
-    #    halt [200, {'Content-Disposition' => "attachment; filename=some-file"}, some_IO_instance]
-    #
-    # @param [Array] *args
-    #
-    def halt *args
-      args.each do |a|
-        case a
-        when Rack::Response
-          throw(:__response__, a.finish)
-        when Fixnum
-          response.status = a
-        when Array
-          if a.size == 3
-            response.status = a[0]
-            response.headers.update(a[1])
-            response.body = a[2]
-            break
-          else
-            response.body = a
-          end
-        when Hash
-          response.headers.update(a)
-        else
-          response.body = a
-        end
-      end
-      throw(:__response__, response.finish)
-    end
-
-    # @example
-    #   flash[:alert] = 'some secret'
-    #   p flash[:alert] #=> "some secret"
-    #   p flash[:alert] #=> nil
-    def flash
-      @__flash_proxy__ ||= RocketIO::Flash.new(session)
-    end
-
-    # Halt processing and redirect to the URI provided.
-    def redirect uri
-      response.status = http_1_1? && !get? ? 303 : 302
-
-      # According to RFC 2616 section 14.30, "the field value consists of a
-      # single absolute URI"
-      response[RocketIO::LOCATION] = uri(uri.to_s)
-      halt
-    end
-
-    def permanent_redirect uri
-      response.status = 301
-      response[RocketIO::LOCATION] = uri(uri.to_s)
-      halt
-    end
-
-    # Generates the absolute URI for a given path in the app.
-    # Takes Rack routers and reverse proxies into account.
-    def uri addr = nil, absolute = true, add_script_name = true
-      return addr if addr && addr =~ /\A[A-z][A-z0-9\+\.\-]*:/
-      uri = [host = ""]
-      if absolute
-        host << "http#{'s' if request.secure?}://"
-        if request.forwarded? or request.port != (request.secure? ? 443 : 80)
-          host << request.host_with_port
-        else
-          host << request.host
-        end
-      end
-      uri << request.script_name.to_s if add_script_name
-      uri << (addr ? addr : request.path_info).to_s
-      File.join(uri)
-    end
-
-    # Set multiple response headers with Hash.
-    def headers hash = nil
-      response.headers.merge!(hash) if hash
-      response.headers
-    end
-
-    # shorthand for content_type(charset: 'something')
-    def charset charset
-      content_type(charset: charset)
-    end
-
-    # returns, set or update content type.
-    # if called without args it will return current content type.
-    # if called with a single argument, given argument will be set as content type.
-    # if a type and hash given it will set brand new content type composed of given type and opts.
-    # if only a hash given it will update current content type with given opts.
-    #   if no content type is set it will use default one + given opts.
-    #
-    # @example set content type
-    #   content_type '.json'
-    #
-    # @example set content type with some params
-    #   content_type '.json', level: 1
-    #
-    # @example add params to current content type
-    #   content_type comment: 'Boo!'
-    #
-    def content_type *args
-      return response[RocketIO::CONTENT_TYPE] if args.empty?
-      params = args.last.is_a?(Hash) ? args.pop.map {|kv| kv.map!(&:to_s)}.to_h : {}
-      default = params.delete('default')
-
-      if type = args.first
-        mime_type = mime_type(type) || default || raise(ArgumentError, "Unknown media type: %p" % type)
-      else
-        mime_type = response[RocketIO::CONTENT_TYPE]
-      end
-      mime_type ||= RocketIO::DEFAULT_CONTENT_TYPE
-
-      mime_type, _params = mime_type.split(';')
-      if _params
-        params = _params.split(',').map! {|o| o.strip.split('=')}.to_h.merge!(params)
-      end
-
-      if params.any?
-        mime_type << '; '
-        mime_type << params.map do |key, val|
-          val = val.inspect if val =~ /[";,]/
-          [key, val]*'='
-        end.join(', ')
-      end
-      response[RocketIO::CONTENT_TYPE] = mime_type
-    end
-
-    # Set the Content-Disposition to "attachment" with the specified filename,
-    # instructing the user agents to prompt to save.
-    def attachment(filename = nil, disposition = 'attachment')
-      response[RocketIO::CONTENT_DISPOSITION] = disposition.to_s
-      if filename
-        response[RocketIO::CONTENT_DISPOSITION] << ('; filename="%s"' % File.basename(filename))
-        ext = File.extname(filename)
-        content_type(ext) unless response[RocketIO::CONTENT_TYPE] or ext.empty?
-      end
-    end
-
-    # Use the contents of the file at +path+ as the response body.
-    def send_file path, opts = {}
-      if opts[:type] or not response[RocketIO::CONTENT_TYPE]
-        content_type(opts[:type] || File.extname(path), default: RocketIO::APPLICATION_OCTET_STREAM)
-      end
-
-      disposition = opts[:disposition]
-      filename    = opts[:filename]
-      disposition = 'attachment' if disposition.nil? and filename
-      filename    = path         if filename.nil?
-      attachment(filename, disposition) if disposition
-
-      last_modified(opts[:last_modified]) if opts[:last_modified]
-
-      file      = Rack::File.new(nil)
-      file.path = path
-      result    = file.serving(env)
-      result[1].each { |k,v| headers[k] ||= v }
-      headers[RocketIO::CONTENT_LENGTH] = result[1][RocketIO::CONTENT_LENGTH]
-      opts[:status] &&= Integer(opts[:status])
-      response.status = opts[:status] || result[0]
-      response.body = result[2]
-      halt
-    rescue Errno::ENOENT
-      error(404)
-    end
-
-    # Specify response freshness policy for HTTP caches (Cache-Control header).
-    # Any number of non-value directives (:public, :private, :no_cache,
-    # :no_store, :must_revalidate, :proxy_revalidate) may be passed along with
-    # a Hash of value directives (:max_age, :min_stale, :s_max_age).
-    #
-    #   cache_control :public, :must_revalidate, :max_age => 60
-    #   => Cache-Control: public, must-revalidate, max-age=60
-    #
-    # See RFC 2616 / 14.9 for more on standard cache control directives:
-    # http://tools.ietf.org/html/rfc2616#section-14.9.1
-    def cache_control *values
-      if values.last.kind_of?(Hash)
-        hash = values.pop
-        hash.reject! { |k,v| v == false }
-        hash.reject! { |k,v| values << k if v == true }
-      else
-        hash = {}
-      end
-
-      values.map! { |value| value.to_s.tr('_','-') }
-      hash.each do |key, value|
-        key = key.to_s.tr('_', '-')
-        value = value.to_i if key == "max-age"
-        values << "#{key}=#{value}"
-      end
-
-      response[RocketIO::CACHE_CONTROL] = values.join(', ') if values.any?
-    end
-
-    # Set the Expires header and Cache-Control/max-age directive. Amount
-    # can be an integer number of seconds in the future or a Time object
-    # indicating when the response should be considered "stale". The remaining
-    # "values" arguments are passed to the #cache_control helper:
-    #
-    #   expires 500, :public, :must_revalidate
-    #   => Cache-Control: public, must-revalidate, max-age=60
-    #   => Expires: Mon, 08 Jun 2009 08:50:17 GMT
-    #
-    def expires amount, *values
-      values << {} unless values.last.kind_of?(Hash)
-
-      if amount.is_a?(Integer)
-        time    = Time.now + amount.to_i
-        max_age = amount
-      else
-        time    = time_for amount
-        max_age = time - Time.now
-      end
-
-      values.last.merge!(:max_age => max_age)
-      cache_control(*values)
-
-      response[RocketIO::EXPIRES] = time.httpdate
-    end
-
-    # Set the last modified time of the resource (HTTP 'Last-Modified' header)
-    # and halt if conditional GET matches. The +time+ argument is a Time,
-    # DateTime, or other object that responds to +to_time+.
-    #
-    # When the current request includes an 'If-Modified-Since' header that is
-    # equal or later than the time specified, execution is immediately halted
-    # with a '304 Not Modified' response.
-    def last_modified time
-      return unless time
-      time = time_for(time)
-      response[RocketIO::LAST_MODIFIED] = time.httpdate
-      return if env[RocketIO::HTTP_IF_NONE_MATCH]
-
-      if response.ok? && env[RocketIO::HTTP_IF_MODIFIED_SINCE]
-        # compare based on seconds since epoch
-        since = Time.httpdate(env[RocketIO::HTTP_IF_MODIFIED_SINCE]).to_i
-        halt(304) if since >= time.to_i
-      end
-
-      if (response.successful? || response.precondition_failed?) && env[RocketIO::HTTP_IF_UNMODIFIED_SINCE]
-        # compare based on seconds since epoch
-        since = Time.httpdate(env[RocketIO::HTTP_IF_UNMODIFIED_SINCE]).to_i
-        halt(412) if since < time.to_i
-      end
-    rescue ArgumentError
-    end
-
-    # Set the response entity tag (HTTP 'ETag' header) and halt if conditional
-    # GET matches. The +value+ argument is an identifier that uniquely
-    # identifies the current version of the resource. The +kind+ argument
-    # indicates whether the etag should be used as a :strong (default) or :weak
-    # cache validator.
-    #
-    # When the current request includes an 'If-None-Match' header with a
-    # matching etag, execution is immediately halted. If the request method is
-    # GET or HEAD, a '304 Not Modified' response is sent.
-    def etag value, options = {}
-      # Before touching this code, please double check RFC 2616 14.24 and 14.26.
-      options      = {:kind => options} unless Hash === options
-      kind         = options[:kind] || :strong
-      new_resource = options.fetch(:new_resource) { request.post? }
-
-      unless RocketIO::ETAG_KINDS.include?(kind)
-        raise ArgumentError, ":strong or :weak expected"
-      end
-
-      value = '"%s"' % value
-      value = "W/#{value}" if kind == :weak
-      response[RocketIO::ETAG] = value
-
-      if response.successful? || response.not_modified?
-        if etag_matches?(env[RocketIO::HTTP_IF_NONE_MATCH], new_resource)
-          response.status = request.safe? ? 304 : 412
-          halt
-        end
-
-        if env[RocketIO::HTTP_IF_MATCH]
-          unless etag_matches?(env[RocketIO::HTTP_IF_MATCH], new_resource)
-            response.status = 412
-            halt
-          end
-        end
-      end
-    end
-
-    # Sugar for redirect (example:  redirect back)
-    def back
-      request.referer
-    end
-
-    # Generates a Time object from the given value.
-    # Used by #expires and #last_modified.
-    def time_for value
-      if value.respond_to?(:to_time)
-        value.to_time
-      elsif value.is_a?(Time)
-        value
-      elsif value.respond_to?(:new_offset)
-        # DateTime#to_time does the same on 1.9
-        d = value.new_offset 0
-        t = Time.utc(d.year, d.mon, d.mday, d.hour, d.min, d.sec + d.sec_fraction)
-        t.getlocal
-      elsif value.respond_to?(:mday)
-        # Date#to_time does the same on 1.9
-        Time.local(value.year, value.mon, value.mday)
-      elsif value.is_a? Numeric
-        Time.at value
-      else
-        Time.parse value.to_s
-      end
-    rescue ArgumentError => boom
-      raise boom
-    rescue Exception
-      raise ArgumentError, "unable to convert #{value.inspect} to a Time object"
-    end
-
-    private
-    # Helper method checking if a ETag value list includes the current ETag.
-    def etag_matches? list, new_resource = request.post?
-      return !new_resource if list == '*'
-      list.to_s.split(/\s*,\s*/).include? response[RocketIO::ETAG]
-    end
-  end
-end