rocketio 0.0.0.pre.alpha → 0.0.0

data/.travis.yml

@@ -1,3 +0,0 @@
-language: ruby
-rvm:
-  - 2.2.2

data/bin/console

@@ -1,14 +0,0 @@
-#!/usr/bin/env ruby
-
-require "bundler/setup"
-require "rocketio"
-
-# You can add fixtures and/or initialization code here to make experimenting
-# with your gem easier. You can also use a different console, if you like.
-
-# (If you use this, don't forget to add pry to your Gemfile!)
-# require "pry"
-# Pry.start
-
-require "irb"
-IRB.start

data/bin/setup

@@ -1,7 +0,0 @@
-#!/bin/bash
-set -euo pipefail
-IFS=$'\n\t'
-
-bundle install
-
-# Do any other automated setup that you need to do here

data/lib/rocketio/application.rb

@@ -1,31 +0,0 @@
-module RocketIO
-  class Application
-
-    def initialize *args, &block
-      controllers = args.empty? ? RocketIO.controllers : args.flatten
-      if block
-        controllers.each {|c| c.class_exec {define_method(:call!, block)}}
-      end
-      @router = Router.new(*controllers)
-    end
-
-    def call env
-      catch :__response__ do # catch 404 errors and potential `halt` calls from middleware
-        controller, path_params = @router.resolve_path(env[PATH_INFO])
-
-        unless controller
-          controller = RocketIO::Controller.initialize_controller
-          controller.env = env
-          controller.error(404)
-        end
-
-        controller = controller.initialize_controller(REQUEST_METHODS[env[REQUEST_METHOD]], path_params)
-        chain = controller.middleware.reverse.inject(controller) {|app,ware| ware.call(app)}
-        if controller.sessions
-          chain = controller.sessions[0].new(chain, controller.sessions[1])
-        end
-        chain.call(env)
-      end
-    end
-  end
-end

data/lib/rocketio/controller.rb

@@ -1,288 +0,0 @@
-module RocketIO
-  class Controller
-    extend Forwardable
-
-    def_delegators 'self.class', :url, :dirname, :parameters_policy
-    def_delegators :request, :session, :request_method
-    def_delegators RocketIO, :indifferent_params, :indifferent_hash, :mime_type, :engine_const, :engine_class
-    def_delegators CGI, :escape_html
-
-    # defining get, post etc. methods that will be called
-    # when a request matches current controller and appropriate request method used.
-    #
-    # by default all requests, except HEAD, will return a NotImplementedError.
-    # override the methods you need to be handled by controller.
-    #
-    RocketIO::REQUEST_METHODS.each_value do |verb|
-      define_method(verb) {|*| error(501)}
-    end
-    def head(*); end
-
-    # call requested method.
-    # also call #before, #around and #after filters.
-    #
-    # @param  [Hash] env
-    # @return [Rack::Response]
-    #
-    def call env
-      catch :__response__ do
-        begin
-          self.env = env
-          validate_or_request_authentication_if_needed
-          validate_or_request_authorization_if_needed
-          validate_parameters
-
-          call! proc {
-            invoke_before_filter
-            invoke_around_filter proc {
-              response.body = public_send(requested_method, *path_params_array)
-            }
-            invoke_after_filter
-          }
-          response.body ||= RocketIO::EMPTY_ARRAY
-          response.body = [] if head? # dropping body on HEAD requests
-          response.finish
-        rescue Exception => e
-          if RocketIO.development?
-            puts "\e[0;31m%s\e[0m" % e.inspect
-            e.backtrace.each {|l| puts "  \e[0;36m%s\e[0m" % l}
-          end
-          error(500, e)
-        end
-      end
-    end
-
-    def call! app
-      app.call
-    end
-
-    def env= env
-      @__env__ = env
-    end
-
-    def env
-      @__env__
-    end
-
-    def validate_parameters
-      # enforce policy only if a method defined for current request method
-      # cause stock REST methods accepting any number of arguments
-      return unless policy = parameters_policy[requested_method]
-
-      if path_params_array.size >= policy[:min]
-        return if policy[:max] == :* || path_params_array.size <= policy[:max]
-      end
-
-      error(409)
-    end
-
-    def path_params
-      @__path_params__ ||= begin
-        rangemap = self.class.path_params[requested_method] ||
-          raise(StandardError, 'No path_params map found for %s method' % requested_method)
-        indifferent_params(rangemap.each_with_object({}) {|(m,r),o|
-          o[m] = r.min == r.max ? path_params_array[r.min] : path_params_array[r]
-        }).freeze
-      end
-    end
-
-    def path_params_array
-      @__path_params_array__
-    end
-
-    def params
-      @__params__ ||= indifferent_params(request.params)
-    end
-
-    def request
-      @__request__ ||= RocketIO::Request.new(env)
-    end
-
-    def response
-      @__response__ ||= RocketIO::Response.new
-    end
-
-    def requested_method
-      @__requested_method__ ||= RocketIO::REQUEST_METHODS[request_method]
-    end
-  end
-
-  class << Controller
-
-    def inherit setup, opts = {}
-      opts[:from] || raise(ArgumentError, ':from option is required')
-      __send__(:"define_#{setup}_methods", opts[:from])
-    end
-
-    def inherited base
-      # registering new controller
-      RocketIO.controllers.push(base)
-
-      # new controller inherits all setups from superclass
-      base.inherit :before, from: self
-      base.inherit :around, from: self
-      base.inherit :after,  from: self
-
-      base.inherit :basic_auth,  from: self
-      base.inherit :digest_auth, from: self
-      base.inherit :token_auth,  from: self
-
-      base.inherit :error_handlers, from: self
-      base.inherit :middleware,     from: self
-      base.inherit :sessions,       from: self
-
-      base.inherit :engine,    from: self
-      base.inherit :layout,    from: self
-      base.inherit :layouts,   from: self
-      base.inherit :templates, from: self
-
-      # removing superclass name from new controller name
-      path = RocketIO.underscore(base.name.to_s.sub(self.name.to_s + '::', '').gsub('::', '/'))
-
-      # new controller uses for URL its underscored name prefixed by superclass URL
-      base.map RocketIO.rootify_path(url, path)
-
-      # setting dirname for new controller
-      base.instance_variable_set(:@__dirname__, RocketIO.caller_to_dirname(caller).freeze)
-    end
-
-    # by default controllers will use underscored name for base URL.
-    # this method allow to set a custom base URL.
-    #
-    # @example Users::Register will listen on /users/register by default
-    #   class Users
-    #     class Register < RocketIO
-    #
-    #     end
-    #   end
-    #
-    # @note
-    #
-    # @example make Users::Register to listen on /users/join rather than /users/register
-    #
-    #   class Users
-    #     class Register < RocketIO
-    #       map :join
-    #
-    #     end
-    #   end
-    #
-    # @note if given URL starts with a slash it will ignore class name and set URL as is
-    #
-    # @example make Users::Register to listen on /members/join
-    #
-    #   class Users < RocketIO
-    #     class Register < self
-    #       map '/members/join'
-    #
-    #     end
-    #   end
-    #
-    # @param path [String || Symbol]
-    #
-    def map path
-      path = path.to_s
-      @__url__ = if path =~ /\A\//
-        path
-      else
-        if superclass == Object
-          RocketIO.rootify_path(path)
-        else
-          RocketIO.rootify_path(superclass.url, path)
-        end
-      end.freeze
-    end
-
-    # allow controllers to serve multiple URLs
-    #
-    # @param path [String || Symbol]
-    #
-    def alias_url path
-      path = path.to_s
-      path = if path =~ /\A\//
-        path
-      else
-        if superclass == Object
-          RocketIO.rootify_path(path)
-        else
-          RocketIO.rootify_path(superclass.url, path)
-        end
-      end.freeze
-      aliases.push(path)
-    end
-
-    def aliases
-      @__aliases__ ||= []
-    end
-
-    # build a URL from given chunks prefixing them with actual path
-    #
-    # @param *args [Array]
-    # @return [String]
-    def url *args
-      return @__url__ if args.empty?
-      query = if args.last.is_a?(Hash)
-        RocketIO::QUERY_PREFIX + ::Rack::Utils.build_nested_query(args.pop)
-      else
-        RocketIO::EMPTY_STRING
-      end
-      ::File.join(@__url__, args.map!(&:to_s)) + query
-    end
-
-    def method_added meth
-      parameters = instance_method(meth).parameters
-      path_params[meth] = RocketIO.path_params(parameters).freeze
-      if requested_method = RocketIO::REQUEST_METHODS.values.find {|verb| verb == meth}
-        # REST methods should be called with a predetermined set of parameters.
-        # setting an appropriate policy for just defined method based on its parameters.
-        parameters_policy[requested_method] = RocketIO.parameters_policy(parameters).freeze
-      end
-    end
-
-    # initializing the controller to process a HTTP request
-    #
-    # @param path_params [Array]
-    # @return a RocketIO::Route instance
-    def initialize_controller requested_method = nil, path_params_array = nil
-      controller = allocate
-      controller.instance_variable_set(:@__requested_method__,  requested_method.to_sym) if requested_method
-      controller.instance_variable_set(:@__path_params_array__,  (path_params_array || []).freeze)
-      controller
-    end
-
-    def parameters_policy
-      @__parameters_policy__ ||= {}
-    end
-
-    def path_params
-      @__path_params__ ||= {}
-    end
-
-    def dirname *args
-      ::File.join(@__dirname__, args.map!(&:to_s))
-    end
-
-    # making controller to act as a Rack application
-    def call env
-      initialize_controller.call(env)
-    end
-
-    def api
-      public_instance_methods(false)
-    end
-  end
-end
-
-require 'rocketio/controller/authentication'
-require 'rocketio/controller/authorization'
-require 'rocketio/controller/cookies'
-require 'rocketio/controller/error_handlers'
-require 'rocketio/controller/filters'
-require 'rocketio/controller/flash'
-require 'rocketio/controller/helpers'
-require 'rocketio/controller/middleware'
-require 'rocketio/controller/request'
-require 'rocketio/controller/response'
-require 'rocketio/controller/sessions'
-require 'rocketio/controller/websocket'
-require 'rocketio/controller/render'

data/lib/rocketio/controller/authentication.rb

@@ -1,141 +0,0 @@
-module RocketIO
-  class Controller
-
-    # easily restrict access to controller using basic auth
-    #
-    # @example protect all request methods
-    #   basic_auth do |user,pass|
-    #     user == 'admin' && pass == 'super secret password'
-    #   end
-    #
-    # @example protect only POST, PUT and DELETE request methods
-    #   basic_auth :post, :put, :delete do |user,pass|
-    #     user == 'admin' && pass == 'super secret password'
-    #   end
-    #
-    # @example use different credentials for GET and POST
-    #   basic_auth :get do |user,pass|
-    #     user == 'reader' && pass == 'readPass'
-    #   end
-    #
-    #   basic_auth :post do |user,pass|
-    #     user == 'poster' && pass == 'writePass'
-    #   end
-    #
-    # @note authorization is composable, that's it, if superclass is protecting :get method
-    #       and current controller protects :post method,
-    #       both :get and :post will be protected in current controller
-    #
-    # @params *args [Array]
-    # @param block [Proc]
-    #
-    def self.basic_auth *args, &block
-      opts = args.last.is_a?(Hash) ? args.pop : {}
-      rqms = args.any? ? args.map!(&:to_sym) : RocketIO::REQUEST_METHODS.values
-      rqms.each do |rm|
-        (@__basic_auth__ ||= {})[rm] = {
-          class:     Rack::Auth::Basic,
-          arguments: [opts[:realm] || RocketIO::DEFAULT_AUTH_REALM].freeze,
-          block:     block,
-          mock:      RocketIO::HTTP_AUTHORIZATION_MOCKS[:basic]
-        }.freeze
-      end
-      define_basic_auth_methods
-    end
-
-    def self.define_basic_auth_methods source = self
-      prompts = (source.instance_variable_get(:@__basic_auth__) || {}).each_with_object(allocate.basic_auth.dup) do |(rm,p),o|
-        method = :"__basic_auth__#{rm}__"
-        define_method(method, &p[:block])
-        o[rm] = p.merge(method: method).freeze
-      end.freeze
-      return if prompts.empty?
-      define_method(:basic_auth) {prompts}
-    end
-
-    def basic_auth; RocketIO::EMPTY_HASH end
-
-    # easily restrict access to controller using digest auth
-    #
-    # @example protect all request methods using hashed passwords
-    #    # hash the password somewhere in irb:
-    #    # ::Digest::MD5.hexdigest 'admin:AccessRestricted:somePassword'
-    #    #                   username ^      realm ^       password ^
-    #
-    #    #=> 9d77d54decc22cdcfb670b7b79ee0ef0
-    #
-    #    digest_auth :passwords_hashed => true, :realm => 'AccessRestricted' do |user|
-    #      {'admin' => '9d77d54decc22cdcfb670b7b79ee0ef0'}[user]
-    #    end
-    #
-    # @example protect all request methods using plain passwords
-    #    digest_auth do |user|
-    #      {'admin' => 'password'}[user]
-    #    end
-    #
-    # @example protect only POST, PUT and DELETE request methods
-    #   digest_auth :post, :put, :delete do |user|
-    #     {'admin' => 'password'}[user]
-    #   end
-    #
-    # @example use different credentials for GET and POST
-    #   digest_auth :get do |user|
-    #     {'user' => 'readPass'}[user]
-    #   end
-    #
-    #   digest_auth :post do |user|
-    #     {'poster' => 'writePass'}[user]
-    #   end
-    #
-    # @params *args [Array]
-    # @param block [Proc]
-    #
-    def self.digest_auth *args, &block
-      opts = args.last.is_a?(Hash) ? args.pop : {}
-      opts[:realm]  ||= RocketIO::DEFAULT_AUTH_REALM
-      opts[:opaque] ||= opts[:realm]
-      rqms = args.any? ? args.map!(&:to_sym) : RocketIO::REQUEST_METHODS.values
-      rqms.each do |rm|
-        (@__digest_auth__ ||= {})[rm] = {
-          class:     Rack::Auth::Digest::MD5,
-          arguments: [opts].freeze,
-          block:     block,
-          mock:      RocketIO::HTTP_AUTHORIZATION_MOCKS[:digest]
-        }.freeze
-      end
-      define_digest_auth_methods
-    end
-
-    def self.define_digest_auth_methods source = self
-      prompts = (source.instance_variable_get(:@__digest_auth__) || {}).each_with_object(allocate.digest_auth.dup) do |(rm,p),o|
-        method = :"__digest_auth__#{rm}__"
-        define_method(method, &p[:block])
-        o[rm] = p.merge(method: method).freeze
-      end.freeze
-      return if prompts.empty?
-      define_method(:digest_auth) {prompts}
-    end
-
-    def digest_auth; RocketIO::EMPTY_HASH end
-
-    def user?
-      env[RocketIO::REMOTE_USER]
-    end
-
-    # checks whether authentication is required and
-    # send an authorization request if credentials not present or invalid
-    def validate_or_request_authentication_if_needed
-      return unless auth = digest_auth[requested_method] || basic_auth[requested_method]
-      return unless prompt = auth[:class].new(proc {}, *auth[:arguments]) do |*a|
-        self.__send__(auth[:method], *a)
-      end.call(
-        if RocketIO::HTTP_AUTHORIZATION_KEYS.detect {|key| env.has_key?(key)}
-          env
-        else
-          env.merge(RocketIO::HTTP_AUTHORIZATION_KEYS.first => auth[:mock])
-        end
-      )
-      throw(:__response__, prompt)
-    end
-  end
-end