midori.rb 0.4.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 710b54063e97c0088cb335bbf2c4719154f0e991
+  data.tar.gz: 0753fd460e35cc8c19e04b6c2ccb561e54d0db69
+SHA512:
+  metadata.gz: a2190c4be4ba8bf93f23d89cb9efb5ed49d5886351689be6bdf2fa0d174d026fad10a13970fcc2a931ff2eb9a384b115615f6f3b2146dbfbb468281f0884f3e9
+  data.tar.gz: a5fa0332c7a506523700728b1970ef32fec0ed9b31c7d8f86d489734fdffcad4499a58ab591247d686769683f97d8d302e255cab8213265988c5f7416b900b56

data/.editorconfig

@@ -0,0 +1,9 @@
+root = true
+
+[*]
+end_of_line = lf
+insert_final_newline = true
+
+[*.rb]
+indent_style = space
+indent_size = 2

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016-2017 HeckPsi Lab
+
+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.

data/ext/midori/extconf.rb

@@ -0,0 +1,4 @@
+require 'mkmf'
+extension_name = 'midori_ext'
+dir_config(extension_name)
+create_makefile(extension_name)

data/ext/midori/websocket.c

@@ -0,0 +1,32 @@
+#include <ruby.h>
+
+VALUE Midori = Qnil;
+VALUE MidoriWebSocket = Qnil;
+
+void Init_midori_ext();
+VALUE method_midori_websocket_mask(VALUE self, VALUE payload, VALUE mask);
+
+void Init_midori_ext() {
+  Midori = rb_define_module("Midori");
+  MidoriWebSocket = rb_define_class_under(Midori, "WebSocket", rb_cObject);
+  rb_define_protected_method(MidoriWebSocket, "mask", method_midori_websocket_mask, 2);
+}
+
+VALUE method_midori_websocket_mask(VALUE self, VALUE payload, VALUE mask) {
+  long n = RARRAY_LEN(payload), i, p, m;
+  VALUE unmasked = rb_ary_new2(n);
+
+  int mask_array[] = {
+    NUM2INT(rb_ary_entry(mask, 0)),
+    NUM2INT(rb_ary_entry(mask, 1)),
+    NUM2INT(rb_ary_entry(mask, 2)),
+    NUM2INT(rb_ary_entry(mask, 3))
+  };
+
+  for (i = 0; i < n; i++) {
+    p = NUM2INT(rb_ary_entry(payload, i));
+    m = mask_array[i % 4];
+    rb_ary_store(unmasked, i, INT2NUM(p ^ m));
+  }
+  return unmasked;
+}

data/lib/midori/api.rb

@@ -0,0 +1,426 @@
+##
+# This class provides methods to be inherited as route definition.
+class Midori::API
+  class << self
+     # @!attribute routes
+     #   @return [Hash] merged routes defined in the instance
+     # @!attribute scope_middlewares
+     #   @return [Array] global middlewares under the scope
+    attr_accessor :routes, :scope_middlewares
+
+    # Init private variables of class
+    # @return [nil] nil
+    def class_initialize
+      @routes = {}
+      Midori::Const::ROUTE_METHODS.map {|method| @routes[method] = []}
+      @routes[:MOUNT] = []
+      @scope_middlewares = []
+      @temp_middlewares = []
+      nil
+    end
+
+    # Add DELETE method as a DSL for route definition
+    # @param [ String ] path Accepts as part of path in route definition
+    # @yield what to run when route matched
+    # @return [ nil ] nil
+    # @example String as router
+    #   delete '/' do
+    #      puts 'Hello World'
+    #   end
+    def delete(path, &block) end
+    
+    # Add GET method as a DSL for route definition
+    # @param [String] path Accepts as part of path in route definition
+    # @yield what to run when route matched
+    # @return [nil] nil
+    # @example String as router
+    #   get '/' do
+    #      puts 'Hello World'
+    #   end
+    def get(path, &block) end
+
+    # Add HEAD method as a DSL for route definition
+    # @param [ String ] path Accepts as part of path in route definition
+    # @yield what to run when route matched
+    # @return [ nil ] nil
+    # @example String as router
+    #   head '/' do
+    #      puts 'Hello World'
+    #   end
+    def head(path, &block) end
+
+    # Add POST method as a DSL for route definition
+    # @param [String] path Accepts as part of path in route definition
+    # @yield what to run when route matched
+    # @return [nil] nil
+    # @example String as router
+    #   post '/' do
+    #      puts 'Hello World'
+    #   end
+    def post(path, &block) end
+
+    # Add PUT method as a DSL for route definition
+    # @param [String] path Accepts as part of path in route definition
+    # @yield what to run when route matched
+    # @return [nil] nil
+    # @example String as router
+    #   put '/' do
+    #      puts 'Hello World'
+    #   end
+    def put(path, &block) end
+
+    # Add CONNECT method as a DSL for route definition
+    # @param [String] path Accepts as part of path in route definition
+    # @yield what to run when route matched
+    # @return [nil] nil
+    # @example String as router
+    #   connect '/' do
+    #      puts 'Hello World'
+    #   end
+    def connect(path, &block) end
+
+    # Add OPTIONS method as a DSL for route definition
+    # @param [String] path Accepts as part of path in route definition
+    # @return [nil] nil
+    # @example String as router
+    #   options '/' do
+    #      puts 'Hello World'
+    #   end
+    def options(path, &block) end
+
+    # Add TRACE method as a DSL for route definition
+    # @param [ String ] path Accepts as part of path in route definition
+    # @yield what to run when route matched
+    # @return [ nil ] nil
+    # @example String as router
+    #   trace '/' do
+    #      puts 'Hello World'
+    #   end
+    def trace(path, &block) end
+
+    # Add COPY method as a DSL for route definition
+    # @param [ String ] path Accepts as part of path in route definition
+    # @yield what to run when route matched
+    # @return [ nil ] nil
+    # @example String as router
+    #   copy '/' do
+    #      puts 'Hello World'
+    #   end
+    def copy(path, &block) end
+
+    # Add LOCK method as a DSL for route definition
+    # @param [ String ] path Accepts as part of path in route definition
+    # @yield what to run when route matched
+    # @return [ nil ] nil
+    # @example String as router
+    #   lock '/' do
+    #      puts 'Hello World'
+    #   end
+    def lock(path, &block) end
+
+    # Add MKCOK method as a DSL for route definition
+    # @param [ String ] path Accepts as part of path in route definition
+    # @yield what to run when route matched
+    # @return [ nil ] nil
+    # @example String as router
+    #   mkcol '/' do
+    #      puts 'Hello World'
+    #   end
+    def mkcol(path, &block) end
+
+    # Add MOVE method as a DSL for route definition
+    # @param [ String ] path Accepts as part of path in route definition
+    # @yield what to run when route matched
+    # @return [ nil ] nil
+    # @example String as router
+    #   move '/' do
+    #      puts 'Hello World'
+    #   end
+    def move(path, &block) end
+
+
+    # Add PROPFIND method as a DSL for route definition
+    # @param [ String ] path Accepts as part of path in route definition
+    # @yield what to run when route matched
+    # @return [ nil ] nil
+    # @example String as router
+    #   propfind '/' do
+    #      puts 'Hello World'
+    #   end
+    def propfind(path, &block) end
+    
+    # Add PROPPATCH method as a DSL for route definition
+    # @param [ String ] path Accepts as part of path in route definition
+    # @yield what to run when route matched
+    # @return [ nil ] nil
+    # @example String as router
+    #   proppatch '/' do
+    #      puts 'Hello World'
+    #   end
+    def proppatch(path, &block) end
+
+    # Add UNLOCK method as a DSL for route definition
+    # @param [ String ] path Accepts as part of path in route definition
+    # @yield what to run when route matched
+    # @return [ nil ] nil
+    # @example String as router
+    #   unlock '/' do
+    #      puts 'Hello World'
+    #   end
+    def unlock(path, &block) end
+
+    # Add REPORT method as a DSL for route definition
+    # @param [ String ] path Accepts as part of path in route definition
+    # @yield what to run when route matched
+    # @return [ nil ] nil
+    # @example String as router
+    #   report '/' do
+    #      puts 'Hello World'
+    #   end
+    def report(path, &block) end
+  
+    # Add MKACTIVITY method as a DSL for route definition
+    # @param [ String ] path Accepts as part of path in route definition
+    # @yield what to run when route matched
+    # @return [ nil ] nil
+    # @example String as router
+    #   mkactivity '/' do
+    #      puts 'Hello World'
+    #   end
+    def mkactivity(path, &block) end
+
+    # Add CHECKOUT method as a DSL for route definition
+    # @param [ String ] path Accepts as part of path in route definition
+    # @yield what to run when route matched
+    # @return [ nil ] nil
+    # @example String as router
+    #   checkout '/' do
+    #      puts 'Hello World'
+    #   end
+    def checkout(path, &block) end
+
+    # Add MERGE method as a DSL for route definition
+    # @param [ String ] path Accepts as part of path in route definition
+    # @yield what to run when route matched
+    # @return [ nil ] nil
+    # @example String as router
+    #   merge '/' do
+    #      puts 'Hello World'
+    #   end
+    def merge(path, &block) end
+
+    # Add M-SEARCH method as a DSL for route definition
+    # @param [ String ] path Accepts as part of path in route definition
+    # @yield what to run when route matched
+    # @return [ nil ] nil
+    # @example String as router
+    #   msearch '/' do
+    #      puts 'Hello World'
+    #   end
+    def msearch(path, &block)
+      add_route(:'M-SEARCH', path, block)
+    end
+
+    # Add NOTIFY method as a DSL for route definition
+    # @param [ String ] path Accepts as part of path in route definition
+    # @yield what to run when route matched
+    # @return [ nil ] nil
+    # @example String as router
+    #   notify '/' do
+    #      puts 'Hello World'
+    #   end
+    def notify(path, &block) end
+
+    # Add SUBSCRIBE method as a DSL for route definition
+    # @param [ String ] path Accepts as part of path in route definition
+    # @yield what to run when route matched
+    # @return [ nil ] nil
+    # @example String as router
+    #   subscribe '/' do
+    #      puts 'Hello World'
+    #   end
+    def subscribe(path, &block) end
+
+    # Add UNSUBSCRIBE method as a DSL for route definition
+    # @param [ String ] path Accepts as part of path in route definition
+    # @yield what to run when route matched
+    # @return [ nil ] nil
+    # @example String as router
+    #   unsubscribe '/' do
+    #      puts 'Hello World'
+    #   end
+    def unsubscribe(path, &block) end
+
+    # Add PATCH method as a DSL for route definition
+    # @param [ String ] path Accepts as part of path in route definition
+    # @yield what to run when route matched
+    # @return [ nil ] nil
+    # @example String as router
+    #   patch '/' do
+    #      puts 'Hello World'
+    #   end
+    def patch(path, &block) end
+
+    # Add PURGE method as a DSL for route definition
+    # @param [ String ] path Accepts as part of path in route definition
+    # @yield what to run when route matched
+    # @return [ nil ] nil
+    # @example String as router
+    #   purge '/' do
+    #      puts 'Hello World'
+    #   end
+    def purge(path, &block) end
+
+    # Add LINK method as a DSL for route definition
+    # @param [String] path Accepts as part of path in route definition
+    # @yield what to run when route matched
+    # @return [nil] nil
+    # @example String as router
+    #   link '/' do
+    #      puts 'Hello World'
+    #   end
+    def link(path, &block) end
+
+    # Add UNLINK method as a DSL for route definition
+    # @param [String] path Accepts as part of path in route definition
+    # @yield what to run when route matched
+    # @return [nil] nil
+    # @example String as router
+    #   unlink '/' do
+    #      puts 'Hello World'
+    #   end
+    def unlink(path, &block) end
+
+    # Add WEBSOCKET method as a DSL for route definition
+    # @param [String] path Accepts as part of path in route definition
+    # @yield what to run when route matched
+    # @return [nil] nil
+    # @example String as router
+    #   websocket '/' do
+    #      puts 'Hello World'
+    #   end
+    def websocket(path, &block) end
+
+    # Add EVENTSOURCE method as a DSL for route definition
+    # @param [String] path Accepts as part of path in route definition
+    # @yield what to run when route matched
+    # @return [nil] nil
+    # @example String as router
+    #   eventsource '/' do
+    #      puts 'Hello World'
+    #   end
+    def eventsource(path, &block) end
+
+    # Mount a route prefix with another API defined
+    # @param [String] prefix prefix of the route String
+    # @param [Class] api inherited from Midori::API
+    # @return [nil] nil
+    def mount(prefix, api)
+      raise ArgumentError if prefix == '/' # Cannot mount route API
+      @routes[:MOUNT] << [prefix, api]
+      nil
+    end
+
+    # Definitions for global error handler
+    # @param [Class] error Error class, must be inherited form StandardError
+    # @yield what to do to deal with error
+    # @yieldparam [StandardError] e the detailed error
+    # @example Basic Usage
+    #   capture Midori::InternalError do |e|
+    #     Midori::Response(500, {}, e.backtrace)
+    #   end
+    def capture(error, &block)
+      Midori::Sandbox.add_rule(error, block)
+      nil
+    end
+
+    # Implementation of route DSL
+    # @param [String] method HTTP method
+    # @param [String, Regexp] path path definition
+    # @param [Proc] block process to run when route matched
+    # @return [nil] nil
+    private def add_route(method, path, block)
+      # Argument check
+      raise ArgumentError unless path.is_a?String
+
+      # Insert route to routes
+      route = Midori::Route.new(method, path, block)
+      route.middlewares = @scope_middlewares + @temp_middlewares
+      @routes[method] << route
+
+      # Clean up temp middleware
+      @temp_middlewares = []
+      nil
+    end
+
+    # Use a middleware in the all routes
+    # @param [Class] middleware Inherited from +Midori::Middleware+
+    # @return [nil] nil
+    def use(middleware, *args)
+      middleware = middleware.new(*args)
+      @scope_middlewares << middleware
+      nil
+    end
+
+    # Use a middleware in the next route
+    # @param [Class] middleware Inherited from +Midori::Middleware+
+    # @return [nil] nil
+    def filter(middleware, *args)
+      middleware = middleware.new(*args)
+      @temp_middlewares << middleware
+      nil
+    end
+
+    # Helper block for defining methods in APIs
+    # @param [Symbol] name name of the method
+    # @yield define what to run in CleanRoom
+    def helper(name, &block)
+      Midori::CleanRoom.class_exec do
+        define_method(name, &block)
+      end
+    end
+
+    private def inherited(subclass)
+      subclass.class_initialize
+    end
+  end
+
+  # Constants of supported methods in route definition
+  METHODS = %w( delete
+                get
+                head
+                post
+                put
+                connect
+                options
+                trace
+                copy
+                lock
+                mkcol
+                move
+                propfind
+                proppatch
+                unlock
+                report
+                mkactivity
+                checkout
+                merge
+                notify
+                subscribe
+                unsubscribe
+                patch
+                purge
+                websocket
+                eventsource
+              ).freeze
+
+  # Magics to fill DSL methods through dynamically class method definition
+  METHODS.each do |method|
+    define_singleton_method(method) do |*args, &block|
+      add_route(method.upcase.to_sym, args[0], block) # args[0]: path
+    end
+  end
+
+  singleton_class.send :alias_method, :ws, :websocket
+  singleton_class.send :alias_method, :es, :eventsource
+end

data/lib/midori/api_engine.rb

@@ -0,0 +1,109 @@
+##
+# Merge and manage all APIs.
+# @attr [Hash] routes A hash of all routes merged
+class Midori::APIEngine
+  attr_accessor :routes
+
+  # Init an API Engine
+  # @param [Class] root_api API inherited from [Midori::API]
+  # @param [Symbol] type type mustermann support
+  def initialize(root_api, type = :sinatra)
+    @routes = {}
+    Midori::Const::ROUTE_METHODS.map {|method| @routes[method] = []}  
+    @root_api = root_api
+    @type = type
+    @routes = merge('', root_api, [])
+    @routes.delete :MOUNT
+    @routes.each do |method|
+      method[1].each do |route|
+        route.path = Mustermann.new(route.path, type: type)
+      end
+    end
+  end
+
+  # Merge all routes with a Depth-first search
+  private def merge(prefix, root_api, middlewares)
+    root_api.routes[:MOUNT].each do |mount|
+      root_api.routes.merge!(merge(mount[0], mount[1], root_api.scope_middlewares)) do |_key, old_val, new_val|
+        old_val + new_val
+      end
+    end
+    root_api.routes.delete :MOUNT
+    root_api.routes.each do |method|
+      method[1].each do |route|
+        route.path = prefix + route.path
+        route.middlewares = middlewares + route.middlewares
+      end
+    end
+    root_api.routes
+  end
+
+  # Process after receive data from client
+  # @param request [Midori::Request] Http Raw Request
+  # @param connection [Midori::Connection] A connection created by EventMachine
+  # @return [Midori::Response] Http Response
+  # @raise [Midori::Error::NotFound] If no route matched
+  def receive(request, connection = nil)
+    @routes[request.method].each do |route|
+      params = route.path.params(request.path)
+      next unless params # Skip if not matched
+      request.params = params
+      clean_room = Midori::CleanRoom.new(request)
+      if request.websocket?
+        # Send 101 Switching Protocol
+        connection.send_data Midori::Response.new(
+          status: 101,
+          header: Midori::APIEngine.websocket_header(request.header['Sec-WebSocket-Key']),
+          body: '')
+        connection.websocket.request = request
+        Midori::Sandbox.run(clean_room, route.function, connection.websocket)
+        return Midori::Response.new
+      elsif request.eventsource?
+        connection.send_data Midori::Response.new(
+          status: 200,
+          header: Midori::Const::EVENTSOURCE_HEADER)
+        Midori::Sandbox.run(clean_room, route.function, connection.eventsource)
+        return Midori::Response.new
+      else
+        request = middleware_exec(route.middlewares, clean_room, request)
+        return request if request.is_a? Midori::Response # Early stop
+        result = Midori::Sandbox.run(clean_room, route.function)
+        clean_room.body = result
+        response = result.is_a?(Midori::Response) ? result : clean_room.raw_response
+        response = middleware_exec(route.middlewares, clean_room, request, response)
+        return response
+      end
+    end
+    raise Midori::Exception::NotFound
+  end
+
+  # Return websocket header with given key
+  # @param [String] key 'Sec-WebSocket-Key' in request header
+  # @return [Hash] header
+  def self.websocket_header(key)
+    header = Midori::Const::WEBSOCKET_HEADER.clone
+    header['Sec-WebSocket-Accept'] = Digest::SHA1.base64digest(key + '258EAFA5-E914-47DA-95CA-C5AB0DC85B11')
+    header
+  end
+
+  # Exec middlewares
+  private def middleware_exec(middlewares, clean_room, request, response=nil)
+    result = response.nil? ? request : response
+    middlewares.each do |middleware|
+      if response.nil?
+        result = Midori::Sandbox.run(
+          clean_room,
+          proc { |req| middleware.before(req) },
+          result)
+      else
+        result = Midori::Sandbox.run(
+          clean_room,
+          proc { |req, resp| middleware.after(req, resp) },
+          request,
+          result)
+      end
+      return result if response.nil? && result.is_a?(Midori::Response) # Early stop
+    end
+    result
+  end
+end

data/lib/midori/clean_room.rb

@@ -0,0 +1,24 @@
+##
+# This class is used to be sandbox of requests processing.
+# @attr [Integer] status HTTP response code
+# @attr [Hash] header HTTP response header
+# @attr [Object] body HTTP response body. String could is accepted by default, but could leave for further process with +Midori::Middleware+
+# @attr [Midori::Request] request HTTP request
+class Midori::CleanRoom
+  attr_accessor :status, :header, :body, :request
+
+  # Init a Cleanroom for running
+  # @param [Midori::Request] request HTTP request
+  def initialize(request)
+    @status = 200
+    @header = Midori::Const::DEFAULT_HEADER.clone
+    @body = ''
+    @request = request
+  end
+
+  # Generate response from variables inside +Midori::CleanRoom+
+  # @return [Midori::Response] midori response
+  def raw_response
+    Midori::Response.new(status: @status, header: @header, body: @body)
+  end
+end

data/lib/midori/configure.rb

@@ -0,0 +1,12 @@
+##
+# Default configuration of Midori, extends +Configurable+
+class Midori::Configure
+  extend Configurable
+
+  set :logger, ::Logger.new(STDOUT)
+  set :protocol, :http
+  set :bind, '127.0.0.1'
+  set :port, 8080
+  set :route_type, :sinatra
+  set :before, proc {}
+end