rocketio 0.0.0 → 0.0.1

data/lib/rocketio/controller/request.rb

@@ -0,0 +1,115 @@
+# 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 Request < Rack::Request
+
+    HEADER_PARAM = /\s*[\w.]+=(?:[\w.]+|"(?:[^"\\]|\\.)*")?\s*/
+    HEADER_VALUE_WITH_PARAMS = /(?:(?:\w+|\*)\/(?:\w+(?:\.|\-|\+)?|\*)*)\s*(?:;#{HEADER_PARAM})*/
+
+    # Returns an array of acceptable media types for the response
+    def accept
+      @__accept__ ||= begin
+        if env.include?(HTTP_ACCEPT) and !(accept = env[HTTP_ACCEPT].to_s).empty?
+          accept.scan(HEADER_VALUE_WITH_PARAMS).map! {|e| AcceptEntry.new(e)}.sort
+        else
+          [AcceptEntry.new('*/*')]
+        end
+      end
+    end
+
+    def accept?(type)
+      preferred_type(type).to_s.include?(type)
+    end
+
+    def preferred_type(*types)
+      accepts = accept # just evaluate once
+      return accepts.first if types.empty?
+      types.flatten!
+      return types.first if accepts.empty?
+      accepts.detect do |pattern|
+        type = types.detect { |t| File.fnmatch(pattern, t) }
+        return type if type
+      end
+    end
+
+    alias secure? ssl?
+
+    def forwarded?
+      env.include?(HTTP_X_FORWARDED_HOST)
+    end
+
+    def safe?
+      get? or head? or options? or trace?
+    end
+
+    def idempotent?
+      safe? or put? or delete? or link? or unlink?
+    end
+
+    class AcceptEntry
+      attr_accessor :params
+      attr_reader :entry
+
+      def initialize(entry)
+        params = entry.scan(HEADER_PARAM).map! do |s|
+          key, value = s.strip.split('=', 2)
+          value = value[1..-2].gsub(/\\(.)/, '\1') if value.start_with?('"')
+          [key, value]
+        end
+
+        @entry  = entry
+        @type   = entry[/[^;]+/].delete(' ')
+        @params = Hash[params]
+        @q      = @params.delete('q') { 1.0 }.to_f
+      end
+
+      def <=>(other)
+        other.priority <=> self.priority
+      end
+
+      def priority
+        # We sort in descending order; better matches should be higher.
+        [ @q, -@type.count('*'), @params.size ]
+      end
+
+      def to_str
+        @type
+      end
+
+      def to_s(full = false)
+        full ? entry : to_str
+      end
+
+      def respond_to?(*args)
+        super or to_str.respond_to?(*args)
+      end
+
+      def method_missing(*args, &block)
+        to_str.send(*args, &block)
+      end
+    end
+  end
+end

data/lib/rocketio/controller/response.rb

@@ -0,0 +1,84 @@
+# 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 Response < Rack::Response
+
+    def body= value
+      @body = case value
+      when Rack::Response
+        value.body
+      when Proc
+        def value.each; yield(call) end
+        value
+      when String
+        [value]
+      else
+        value
+      end
+    end
+
+    def empty_body?
+      @body == EMPTY_ARRAY || @body.nil?
+    end
+
+    def each
+      block_given? ? super : enum_for(:each)
+    end
+
+    def finish
+      headers[CONTENT_TYPE] ||= DEFAULT_CONTENT_TYPE
+
+      if drop_content_info?
+        headers.delete(CONTENT_LENGTH)
+        headers.delete(CONTENT_TYPE)
+      end
+
+      if drop_body?
+        close
+        self.body = EMPTY_ARRAY
+      end
+
+      [status.to_i, headers, self.body]
+    end
+
+    def precondition_failed?
+      status.to_i == 412
+    end
+
+    def not_modified?
+      status.to_i == 304
+    end
+
+    private
+    def drop_content_info?
+      status.to_i / 100 == 1 || drop_body?
+    end
+
+    def drop_body?
+      DROP_BODY_RESPONSES[status.to_i]
+    end
+  end
+end

data/lib/rocketio/controller/sessions.rb

@@ -0,0 +1,64 @@
+module RocketIO
+  class Controller
+
+    # setup sessions.
+    # there are 2 setups out of the box:
+    #   - cookies
+    #   - memcache
+    # you can also use your own setup
+    #
+    # @note to disable sessions for some controller set sessions to nil or false
+    #
+    # @example keep sessions in cookies
+    #   sessions :cookies
+    #
+    # @example keep sessions in cookies using custom options
+    #   sessions :cookies, secret: 'someSecret', domain: 'some.domain'
+    #
+    # @example keep sessions in memcache
+    #   sessions :memcache
+    #
+    # @example use a custom setup, i.e. github.com/migrs/rack-session-mongo
+    #   $ gem install rack-session-mongo
+    #
+    #   require 'rack/session/mongo'
+    #
+    #   class Pages < RocketIO::Controller
+    #     sessions Rack::Session::Mongo
+    #   end
+    #
+    # @example disable sessions for current controller
+    #   sessions nil # or false
+    #
+    # @param pool [Symbol, Class]
+    # @param opts [Hash]
+    #
+    def self.sessions pool = (noargs = true; nil), opts = {}
+      @__sessions__ = if pool.nil? || pool == false
+        nil
+      else
+        if pool == :cookies && opts[:secret].nil?
+          opts[:secret] = ::Digest::MD5.hexdigest([Time.now.to_f, rand]*'')
+        end
+        pool = case pool
+        when :cookies
+          ::Rack::Session::Cookie
+        when :memcache
+          ::Rack::Session::Memcache
+        else
+          pool
+        end
+        [pool, opts]
+      end
+      define_sessions_methods
+    end
+
+    def self.define_sessions_methods source = self
+      return unless source.instance_variables.include?(:@__sessions__)
+      sessions = source.instance_variable_get(:@__sessions__)
+      define_method(:sessions) {sessions}
+    end
+
+    def sessions; end
+  end
+end

data/lib/rocketio/controller/token_auth.rb

@@ -0,0 +1,118 @@
+# Copyright (c) 2004-2015 David Heinemeier Hansson
+# 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
+  module TokenAuth
+    extend self
+
+    TOKEN_KEY = 'token='.freeze
+    TOKEN_REGEX = /^Token /
+    AUTHN_PAIR_DELIMITERS = /(?:,|;|\t+)/
+
+    HTTP_AUTHORIZATION = 'HTTP_AUTHORIZATION'.freeze
+    X_HTTP_AUTHORIZATION_I = 'X-HTTP_AUTHORIZATION'.freeze
+    X_HTTP_AUTHORIZATION_II = 'X_HTTP_AUTHORIZATION'.freeze
+    REDIRECT_X_HTTP_AUTHORIZATION = 'REDIRECT_X_HTTP_AUTHORIZATION'.freeze
+
+    WWW_AUTHENTICATE = 'WWW-Authenticate'.freeze
+    TOKEN_REALM_FORMAT = 'Token realm="%s"'.freeze
+    ACCESS_DENIED = "HTTP Token: Access denied.\n".freeze
+
+    # If token Authorization header is present, call the login
+    # procedure with the present token and options.
+    #
+    # @return the return value of given block if a token is found
+    # @return nil if no token is found
+    def authenticate env
+      token, options = token_and_options(env)
+      return if token.nil? || token.empty?
+      yield(token, options)
+    end
+
+    # Parses the token and options out of the token authorization header. If
+    # the header looks like this:
+    #   Authorization: Token token="abc", nonce="def"
+    # Then the returned token is "abc", and the options is {nonce: "def"}
+    #
+    # @return [Array] if a token is present
+    # @return nil if no token is found
+    def token_and_options env
+      return unless authorization_request = authorization?(env)
+      return unless authorization_request[TOKEN_REGEX]
+      params = token_params_from(authorization_request)
+      [params.shift[1], RocketIO.indifferent_params(Hash[params])]
+    end
+
+    # Returns the authorization header regardless of whether it was specified directly or through one of the
+    # proxy alternatives.
+    def authorization? env
+      env[HTTP_AUTHORIZATION] ||
+        env[X_HTTP_AUTHORIZATION_I] ||
+        env[X_HTTP_AUTHORIZATION_II] ||
+        env[REDIRECT_X_HTTP_AUTHORIZATION]
+    end
+
+    def token_params_from auth
+      rewrite_param_values(params_array_from(raw_params(auth)))
+    end
+
+    # Takes raw_params and turns it into an array of parameters
+    #
+    # @param raw_params [Array]
+    # @return           [Array]
+    def params_array_from raw_params
+      raw_params.map { |param| param.split %r/=(.+)?/ }
+    end
+
+    # This removes the `"` characters wrapping the value.
+    #
+    # @param array_params [Array]
+    def rewrite_param_values array_params
+      array_params.each { |param| (param[1] || "").gsub! %r/^"|"$/, '' }
+    end
+
+    # This method takes an authorization body and splits up the key-value
+    # pairs by the standardized `:`, `;`, or `\t`
+    #
+    # @param auth [String]
+    # @return     [Array]
+    def raw_params auth
+      _raw_params = auth.sub(TOKEN_REGEX, '').split(/\s*#{AUTHN_PAIR_DELIMITERS}\s*/)
+      unless _raw_params.first =~ %r{\A#{TOKEN_KEY}}
+        _raw_params[0] = [TOKEN_KEY, _raw_params.first]*''
+      end
+      _raw_params
+    end
+
+    # Sets a WWW-Authenticate to let the client know a token is desired.
+    #
+    # @param realm [String]
+    # @return [Array]
+    def authentication_request realm
+      [
+        401,
+        {WWW_AUTHENTICATE => TOKEN_REALM_FORMAT % realm.tr('"', '')},
+        [ACCESS_DENIED]
+      ]
+    end
+  end
+end

data/lib/rocketio/controller/websocket.rb

@@ -0,0 +1,21 @@
+module RocketIO
+  class Controller
+
+    def websocket?
+      @__is_websocket__ ||= websocket_connection? && websocket_upgrade? ? 1 : 0
+      @__is_websocket__ == 1
+    end
+
+    def websocket_connection?
+      env[RocketIO::HTTP_CONNECTION].to_s.downcase.split(/ *, */).include?(RocketIO::UPGRADE)
+    end
+
+    def websocket_upgrade?
+      env[RocketIO::HTTP_UPGRADE].to_s.downcase == RocketIO::WEBSOCKET
+    end
+
+    def websocket_response
+      [-1, {}, []]
+    end
+  end
+end

data/lib/rocketio/error_templates/404.html

@@ -0,0 +1,3 @@
+<h1>404: Not Found</h1>
+<hr>
+<h2>"{{env.PATH_INFO}}" page is not here :(</h2>

data/lib/rocketio/error_templates/409.html

@@ -0,0 +1,7 @@
+<h1>Wrong number of arguments received</h1>
+<h2>
+  Controller: {{controller}}<br>
+  Resolved Path: {{resolved_path}}<br>
+  Expected Parameters: {{expected_parameters}}<br>
+  Received Parameters: {{received_parameters}}<br>
+</h2>

data/lib/rocketio/error_templates/500.html

@@ -0,0 +1,3 @@
+<h1>500: Fatal Error</h1>
+<hr>
+<h4>{{error.message}}</h4>

data/lib/rocketio/error_templates/501.html

@@ -0,0 +1,6 @@
+<h1>501: Not Implemented</h1>
+<hr>
+<h2>
+  "{{env.PATH_INFO}}" page found
+  but it is not supposed to work through "{{env.REQUEST_METHOD}}" request method
+</h2>

data/lib/rocketio/error_templates/layout.html

@@ -0,0 +1 @@
+{{{ yield }}}

data/lib/rocketio/exceptions.rb

@@ -0,0 +1,4 @@
+module RocketIO
+  class TemplateError < RuntimeError;  end
+  class LayoutError < RuntimeError;  end
+end

data/lib/rocketio/router.rb

@@ -0,0 +1,65 @@
+module RocketIO
+  class Router
+    ROOT_PATH_PIECES  = [''.freeze].freeze
+    attr_reader :controllers, :routes
+
+    def initialize *controllers
+      @controllers = controllers.flatten.compact.uniq
+      @routes = build_routes
+      freeze!
+    end
+
+    def resolve_path path
+      controllers = @routes
+      pieces = path_pieces(path)
+      depth  = -1
+      controller  = nil
+      offset = 0
+      while controllers = controllers[pieces[depth += 1]]
+        next unless controllers[0]
+        controller  = controllers[0]
+        offset = depth + 1
+      end
+      [controller, pieces[offset .. -1]]
+    end
+
+    private
+    # split given path into an array
+    #
+    # @example /a/b/c
+    #   ["", a", "b", "c"]
+    #
+    # @param path [String]
+    # @return [Array]
+    #
+    def path_pieces path
+      return ROOT_PATH_PIECES if path == SLASH # that's root path, /
+      path.to_s.split(/\/+/)
+    end
+
+    # building a routing tree
+    #
+    # @return [Hash]
+    #
+    def build_routes
+      map = {}
+      @controllers.each do |controller|
+        [controller.url, *controller.aliases].each do |url|
+          depth = 0
+          pieces = path_pieces(url)
+          pieces.inject(map) do |map,chunk|
+            map[chunk] ||= {}
+            map[chunk][0] = controller if pieces.size == (depth += 1)
+            map[chunk]
+          end
+        end
+      end
+      map
+    end
+
+    # freezing the application cause modifying it at runtime may blow the universe
+    def freeze!
+      self.freeze
+    end
+  end
+end