rocketio 0.0.0 → 0.0.1

data/lib/rocketio/controller/flash.rb

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,438 @@
+# 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