rocketio 0.0.0 → 0.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5b54b354445fdc9e9c3fa7dc079e2cf3045bee94
-  data.tar.gz: 86677b1465a64ef8e80e78aaf65d06636b68a4aa
+  metadata.gz: 51fdeef94b06a674a04316766088ddff1366635a
+  data.tar.gz: 8804955067cd66dbbbe011f53481484f69d072fb
 SHA512:
-  metadata.gz: a8e7041276e36a0f353d1ec98e30c6aa633cae9bac32198bcc52a928a803d1e8e51213f2d33e520c9d8ff1c6c98a327e15dce41c695841a2ff3e82a2d84b8007
-  data.tar.gz: d0488ce7f83e2b3a918286add891f7d3c450de5aa506edbc145317932e1ac658c825c877db1c258fa0ca856d42e3ad8b7b2760e42f9866c0b71537c2590e6121
+  metadata.gz: 178ba8589ad57652cd19595dbddef2fe6d4b06e3aa999cc7ea170eafffbb59f9e96e385fa598b11df833ffbea49f241d5a8fe3c8f93eeb8f18d0f658b16db9c3
+  data.tar.gz: c86a96c3d50ba9bc0cb466958550a1b06945f3f040d29225e1e0653b45bb132d2b0fd0dd799b01c58761255a9d54a560667a74888e20383539405fb417630e7f

data/.gitignore

@@ -7,8 +7,5 @@
 /pkg/
 /spec/reports/
 /tmp/
-*.bundle
-*.so
-*.o
-*.a
-mkmf.log
+.DS_Store
+.pryrc

data/.pryrc

@@ -0,0 +1,2 @@
+$:.unshift(File.expand_path('../lib', __FILE__))
+require 'rocketio'

data/.travis.yml

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

data/README.md

@@ -1,6 +1,23 @@
-# Rocketio
+# RocketIO
 
-TODO: Write a gem description
+#### Simple, Fast, Scalable Micro-Web-Framework for Ruby
+
+Sample controller:
+
+```ruby
+class Users < RocketIO::Controller
+
+  # serving GET requests
+  def get
+  end
+
+  # serving POST requests
+  def post
+  end
+
+  # same for other request methods
+end
+```
 
 ## Installation
 
@@ -18,13 +35,13 @@ Or install it yourself as:
 
     $ gem install rocketio
 
-## Usage
+## Controllers
+
 
-TODO: Write usage instructions here
 
 ## Contributing
 
-1. Fork it ( https://github.com/[my-github-username]/rocketio/fork )
+1. Fork it ( https://github.com/sleewoo/rocketio/fork )
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)

data/Rakefile

@@ -1,2 +1,8 @@
-require "bundler/gem_tasks"
+require 'bundler/gem_tasks'
+require 'tokyo'
 
+task :test do
+  Tokyo.run
+end
+
+task default: :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/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

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

data/lib/rocketio.rb

@@ -1,5 +1,133 @@
-require "rocketio/version"
+# core
+require 'uri'
+require 'stringio'
+require 'json'
+require 'cgi'
+require 'digest'
+require 'forwardable'
+# gems
+require 'rack'
+require 'mustache'
+require 'tilt'
 
-module Rocketio
-  # Your code goes here...
+module RocketIO
+  extend self
+
+  ENVIRONMENTS = {
+    'development' => :development,
+    'testing'     => :testing,
+    'stage'       => :stage,
+    'production'  => :production
+  }.freeze
+
+  environment = ENV['APP_ENV'] || ENV['RACK_ENV'] || ENVIRONMENTS.keys[0]
+  unless ENVIRONMENT = ENVIRONMENTS[environment]
+    raise(StandardError, '%s environment not supported. Use one of %s' % [environment.inspect, ENVIRONMENTS.keys*', '])
+  end
+
+  def environment
+    ENVIRONMENT
+  end
+
+  ENVIRONMENTS.each_value do |env|
+    define_method(env.to_s + '?') {ENVIRONMENT == env}
+  end
+
+  GET    = 'GET'.freeze
+  POST   = 'POST'.freeze
+  PUT    = 'PUT'.freeze
+  DELETE = 'DELETE'.freeze
+  HEAD   = 'HEAD'.freeze
+
+  REQUEST_METHODS = {
+    GET    => :get,
+    POST   => :post,
+    PUT    => :put,
+    DELETE => :delete,
+    HEAD   => :head
+  }.freeze
+
+  EMPTY_STRING      = ''.freeze
+  EMPTY_STRING_PROC = proc {RocketIO::EMPTY_STRING}
+  EMPTY_ARRAY       = [].freeze
+  EMPTY_HASH        = {}.freeze
+
+  SLASH        = '/'.freeze
+  QUERY_PREFIX = '?'.freeze
+
+  CONTENT_TYPE             = 'Content-Type'.freeze
+  DEFAULT_CONTENT_TYPE     = 'text/html'.freeze
+  CONTENT_LENGTH           = 'Content-Length'.freeze
+  CONTENT_DISPOSITION      = 'Content-Disposition'.freeze
+  APPLICATION_OCTET_STREAM = 'application/octet-stream'.freeze
+  DEFAULT_AUTH_REALM       = 'AccessRestricted'.freeze
+  DEFAULT_TOKEN_AUTH_REALM = 'Application'.freeze
+
+  REQUEST_METHOD = 'REQUEST_METHOD'.freeze
+  PATH_INFO      = 'PATH_INFO'.freeze
+  HTTP_ACCEPT    = 'HTTP_ACCEPT'.freeze
+  REMOTE_USER    = 'REMOTE_USER'.freeze
+
+  HTTP_CONNECTION          = 'HTTP_CONNECTION'.freeze
+  HTTP_AUTHORIZATION_KEYS  = ['HTTP_AUTHORIZATION', 'X-HTTP_AUTHORIZATION', 'X_HTTP_AUTHORIZATION'].map(&:freeze).freeze
+  HTTP_AUTHORIZATION_MOCKS = {
+    basic:  'Basic Og=='.freeze,
+    digest: 'Digest opaque="", qop="auth", uri="/"'.freeze
+  }.freeze
+  HTTP_UPGRADE             = 'HTTP_UPGRADE'.freeze
+  UPGRADE                  = 'upgrade'.freeze
+  WEBSOCKET                = 'websocket'.freeze
+  HTTP_1_1                 = 'HTTP/1.1'.freeze
+  HTTP_VERSION             = 'HTTP_VERSION'.freeze
+  HTTP_X_FORWARDED_HOST    = 'HTTP_X_FORWARDED_HOST'.freeze
+  HTTP_IF_MATCH            = 'HTTP_IF_MATCH'.freeze
+  HTTP_IF_NONE_MATCH       = 'HTTP_IF_NONE_MATCH'.freeze
+  HTTP_IF_MODIFIED_SINCE   = 'HTTP_IF_MODIFIED_SINCE'.freeze
+  HTTP_IF_UNMODIFIED_SINCE = 'HTTP_IF_UNMODIFIED_SINCE'.freeze
+  HTTP_X_REQUESTED_WITH    = 'HTTP_X_REQUESTED_WITH'.freeze
+  XML_HTTP_REQUEST         = 'XMLHttpRequest'.freeze
+
+  LOCATION       = 'Location'.freeze
+  CACHE_CONTROL  = 'Cache-Control'.freeze
+  EXPIRES        = 'Expires'.freeze
+  LAST_MODIFIED  = 'Last-Modified'.freeze
+  ETAG           = 'ETag'.freeze
+  ETAG_KINDS     = [:strong, :weak].freeze
+
+  DROP_BODY_RESPONSES = {204 => true, 205 => true, 304 => true}.freeze
+
+  ERROR_TEMPLATES = begin
+    path = File.expand_path('../rocketio/error_templates/', __FILE__)
+    templates = {layout: Class.new(Mustache) {self.template = File.read(path + '/layout.html').freeze}}
+    Dir[path + '/*.html'].each_with_object(templates) do |file,templates|
+      next if file =~ /layout\.html\z/
+      template = File.basename(file, File.extname(file)).to_i
+      templates[template] = Class.new(Mustache) {self.template = File.read(file).freeze}
+    end
+  end.freeze
+
+  BEFORE_FORMAT = 'before_%s'.freeze
+  AROUND_FORMAT = 'around_%s'.freeze
+  AFTER_FORMAT  = 'after_%s'.freeze
+  ROUTE_INSPECT_FORMAT = '#<RocketIO::Route:%s>'.freeze
+  ENGINE_CONST_FORMAT  = '%sTemplate'.freeze
+  TEMPLATE_PATH_FORMAT = '%s/%s.%s'.freeze
+
+  FOUND_TEMPLATES    = {}
+  READ_TEMPLATES     = {}
+  COMPILED_TEMPLATES = {}
+
+  DEFAULT_ENGINE = [Tilt::ERBTemplate, [].freeze].freeze
+
+  def controllers
+    @controllers ||= []
+  end
 end
+
+require 'rocketio/util'
+require 'rocketio/exceptions'
+require 'rocketio/controller'
+require 'rocketio/router'
+require 'rocketio/application'
+
+RocketIO::Controller.map(RocketIO::SLASH)

data/lib/rocketio/application.rb

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

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