em-midori 0.1.7.1 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a1141fbd9e570a32ea33eb07ad6687a8b60bf36e
-  data.tar.gz: a8c597845b57be046d0ec3e438e5d83694c5df84
+  metadata.gz: bded68c0e7831eb9e36ee2b49dec6c61c760a815
+  data.tar.gz: de5f760feffc996aa88443e3db67eab589d179d8
 SHA512:
-  metadata.gz: 7dca5dee8b994779f9b684155bb20ac948d068e38b35e2f361a6ca01457b85ac5b1227c2e35ebf862b317343ced90cb567ec82d794e27f71a1c7bcf24c81162c
-  data.tar.gz: 609351a34a8741f942afa9deda5ebf097b5cfdffd17fb153999073e43d9b6bd902ca601237032714ef6a4f4ade9fdd16a4befdebdb9615a34718131a0ec9b8e0
+  metadata.gz: 6ffe68ce957c773adf24da6a5e0c4c94deca32d0a617e29ee9ac10eacf4883e5e1d6cf0c94b0698fa30e9bde26599f4425bd081b38d945d0baa6b97a3d4a620e
+  data.tar.gz: 220b8c5f8ec1af61be67526d24975ccd1387384afd41c7014f7176a4bf2468c4fd061475eb147fd9bc8655e5f06b5b2677f382774bc3d8d1f954ff4b98a8b5b8

data/lib/midori/api.rb

@@ -9,38 +9,11 @@ class Midori::API
     attr_accessor :routes, :scope_middlewares
 
     # Init private variables of class
-    # @return [ nil ] nil
+    # @return [nil] nil
     def class_initialize
-      @routes = {
-        DELETE: [],
-        GET: [],
-        HEAD: [],
-        POST: [],
-        PUT: [],
-        CONNECT: [],
-        OPTIONS: [],
-        TRACE: [],
-        COPY: [],
-        LOCK: [],
-        MKCOL: [],
-        MOVE: [],
-        PROPFIND: [],
-        PROPPATCH: [],
-        UNLOCK: [],
-        REPORT: [],
-        MKACTIVITY: [],
-        CHECKOUT: [],
-        MERGE: [],
-        :'M-SEARCH' => [],
-        NOTIFY: [],
-        SUBSCRIBE: [],
-        UNSUBSCRIBE: [],
-        PATCH: [],
-        PURGE: [],
-        WEBSOCKET: [],
-        EVENTSOURCE: [],
-        MOUNT: []
-      }
+      @routes = {}
+      Midori::Const::ROUTE_METHODS.map {|method| @routes[method] = []}
+      @routes[:MOUNT] = []
       @scope_middlewares = []
       @temp_middlewares = []
       nil
@@ -57,9 +30,9 @@ class Midori::API
     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
+    # @param [String] path Accepts as part of path in route definition
     # @yield what to run when route matched
-    # @return [ nil ] nil
+    # @return [nil] nil
     # @example String as router
     #   get '/' do
     #      puts 'Hello World'
@@ -77,9 +50,9 @@ class Midori::API
     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
+    # @param [String] path Accepts as part of path in route definition
     # @yield what to run when route matched
-    # @return [ nil ] nil
+    # @return [nil] nil
     # @example String as router
     #   post '/' do
     #      puts 'Hello World'
@@ -87,9 +60,9 @@ class Midori::API
     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
+    # @param [String] path Accepts as part of path in route definition
     # @yield what to run when route matched
-    # @return [ nil ] nil
+    # @return [nil] nil
     # @example String as router
     #   put '/' do
     #      puts 'Hello World'
@@ -97,9 +70,9 @@ class Midori::API
     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
+    # @param [String] path Accepts as part of path in route definition
     # @yield what to run when route matched
-    # @return [ nil ] nil
+    # @return [nil] nil
     # @example String as router
     #   connect '/' do
     #      puts 'Hello World'
@@ -107,8 +80,8 @@ class Midori::API
     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
+    # @param [String] path Accepts as part of path in route definition
+    # @return [nil] nil
     # @example String as router
     #   options '/' do
     #      puts 'Hello World'
@@ -174,7 +147,7 @@ class Midori::API
     #   propfind '/' do
     #      puts 'Hello World'
     #   end
-    def proppatch(path, &block) 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
@@ -266,7 +239,7 @@ class Midori::API
     #   subscribe '/' do
     #      puts 'Hello World'
     #   end
-    def merge(path, &block) 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
@@ -299,9 +272,9 @@ class Midori::API
     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
+    # @param [String] path Accepts as part of path in route definition
     # @yield what to run when route matched
-    # @return [ nil ] nil
+    # @return [nil] nil
     # @example String as router
     #   link '/' do
     #      puts 'Hello World'
@@ -309,9 +282,9 @@ class Midori::API
     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
+    # @param [String] path Accepts as part of path in route definition
     # @yield what to run when route matched
-    # @return [ nil ] nil
+    # @return [nil] nil
     # @example String as router
     #   unlink '/' do
     #      puts 'Hello World'
@@ -319,9 +292,9 @@ class Midori::API
     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
+    # @param [String] path Accepts as part of path in route definition
     # @yield what to run when route matched
-    # @return [ nil ] nil
+    # @return [nil] nil
     # @example String as router
     #   websocket '/' do
     #      puts 'Hello World'
@@ -329,8 +302,8 @@ class Midori::API
     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
-    # @return [ nil ] nil
+    # @param [String] path Accepts as part of path in route definition
+    # @return [nil] nil
     # @example String as router
     #   eventsource '/' do
     #      puts 'Hello World'
@@ -338,9 +311,9 @@ class Midori::API
     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
+    # @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]
@@ -348,9 +321,9 @@ class Midori::API
     end
 
     # Definitions for global error handler
-    # @param [ Class ] error Error class, must be inherited form StandardError
+    # @param [Class] error Error class, must be inherited form StandardError
     # @yield what to do to deal with error
-    # @yieldparam [ StandardError ] e the detailed error
+    # @yieldparam [StandardError] e the detailed error
     # @example Basic Usage
     #   capture Midori::InternalError do |e|
     #     Midori::Response(500, {}, e.backtrace)
@@ -361,10 +334,10 @@ class Midori::API
     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
+    # @param [String] method HTTP method
+    # @param [String, Regexp] path path definition
+    # @param [Proc] block process to run when route matched
+    # @return [nil] nil
     def add_route(method, path, block)
       # Argument check
       raise ArgumentError unless path.is_a?String

data/lib/midori/api_engine.rb

@@ -1,42 +1,15 @@
 ##
 # Merge and manage all APIs.
-# @attr [ Hash ] routes A hash of all routes merged
+# @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
+  # @param [Class] root_api API inherited from [Midori::API]
+  # @param [Symbol] type type mustermann support
   def initialize(root_api, type = :sinatra)
-    @routes = {
-      DELETE: [],
-      GET: [],
-      HEAD: [],
-      POST: [],
-      PUT: [],
-      CONNECT: [],
-      OPTIONS: [],
-      TRACE: [],
-      COPY: [],
-      LOCK: [],
-      MKCOL: [],
-      MOVE: [],
-      PROPFIND: [],
-      PROPPATCH: [],
-      UNLOCK: [],
-      REPORT: [],
-      MKACTIVITY: [],
-      CHECKOUT: [],
-      MERGE: [],
-      :'M-SEARCH' => [],
-      NOTIFY: [],
-      SUBSCRIBE: [],
-      UNSUBSCRIBE: [],
-      PATCH: [],
-      PURGE: [],
-      WEBSOCKET: [],
-      EVENTSOURCE: []
-    }
+    @routes = {}
+    Midori::Const::ROUTE_METHODS.map {|method| @routes[method] = []}  
     @root_api = root_api
     @type = type
     @routes = merge('', root_api, [])
@@ -66,10 +39,10 @@ class Midori::APIEngine
   end
 
   # Process after receive data from client
-  # @param request [ Midori::Request ] Http Raw Request
-  # @param connection [ EM::Connection ] A connection created by EventMachine
-  # @return [ Midori::Response ] Http Response
-  # @raise [ Midori::Error::NotFound ] If no route matched
+  # @param request [Midori::Request] Http Raw Request
+  # @param connection [EM::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)

data/lib/midori/const.rb

@@ -84,4 +84,34 @@ module Midori::Const
     'Upgrade' => 'websocket',
     'Connection' => 'Upgrade'
   }
+
+  ROUTE_METHODS = %i(
+    DELETE
+    GET
+    HEAD
+    POST
+    PUT
+    CONNECT
+    OPTIONS
+    TRACE
+    COPY
+    LOCK
+    MKCOL
+    MOVE
+    PROPFIND
+    PROPPATCH
+    UNLOCK
+    REPORT
+    MKACTIVITY
+    CHECKOUT
+    MERGE
+    M-SEARCH
+    NOTIFY
+    SUBSCRIBE
+    UNSUBSCRIBE
+    PATCH
+    PURGE
+    WEBSOCKET
+    EVENTSOURCE
+  )
 end

data/lib/midori/core_ext/proc.rb

@@ -1,12 +1,12 @@
 ##
 # Meta-programming Proc for Syntactic Sugars
 class Proc
-  # Convert [ Proc ] to [ Lambda ]
-  # @param [ Object ] instance the context
-  # @return [ Lambda ] Lambda converted
+  # Convert [Proc] to [Lambda]
+  # @param [Object] instance the context
+  # @return [Lambda] Lambda converted
   # @note Converting [Proc] to [Lambda] may have incorrect behaviours on corner cases.
   # @note See {Ruby Language Issues}[https://bugs.ruby-lang.org/issues/7314] for more details.
-  def to_lambda (instance = Object.new)
+  def to_lambda(instance = Object.new)
     instance.define_singleton_method(:_, &self)
     instance.method(:_).to_proc
   end

data/lib/midori/core_ext/promise.rb

@@ -3,15 +3,15 @@
 # Referenced from {Qiita}[http://qiita.com/south37/items/99a60345b22ef395d424]
 class Promise
   # Init a Promise
-  # @param [ Proc ] callback an async method
+  # @param [Proc] callback an async method
   def initialize(callback)
     @callback = callback
   end
 
   # Define what to do after a method callbacks
-  # @param [ Proc ] resolve what on callback
-  # @param [ Proc ] reject what on callback failed
-  # @return [ nil ] nil
+  # @param [Proc] resolve what on callback
+  # @param [Proc] reject what on callback failed
+  # @return [nil] nil
   def then(resolve = ->() {}, reject = ->() {})
     @callback.call(resolve, reject)
   end
@@ -20,7 +20,7 @@ end
 # A Syntactic Sugar for Promise
 class DeferPromise < Promise
   # A Syntactic Sugar for Promise
-  # @param [ proc ] deffered To do what asynchronous
+  # @param [Proc] deffered To do what asynchronous
   def initialize(deffered)
     super(->(resolve, _reject){
       EventMachine.defer(proc {
@@ -36,7 +36,7 @@ end
 
 module Kernel
   # Logic dealing of async method
-  # @param [ Fiber ] fiber a fiber to call
+  # @param [Fiber] fiber a fiber to call
   def async_internal(fiber)
     chain = lambda do |result|
       return unless result.is_a?Promise
@@ -48,7 +48,7 @@ module Kernel
   end
 
   # Define an async method
-  # @param [ Symbol ] method_name method name
+  # @param [Symbol] method_name method name
   # @yield async method
   # @example
   #   async :hello do 
@@ -60,15 +60,15 @@ module Kernel
     }
   end
 
-  # Shortcut to init [ DeferPromise ]
+  # Shortcut to init [DeferPromise]
   # @yield To do what asynchronous
-  # @return [ DerferPromise ] instance
+  # @return [DerferPromise] instance
   def defer(&block)
     DeferPromise.new(block)
   end
 
   # Block the I/O to wait for async method response
-  # @param [ Promise ] promise promise method
+  # @param [Promise] promise promise method
   # @example
   #   result = await SQL.query('SELECT * FROM hello')
   def await(promise)

data/lib/midori/core_ext/promise_exception.rb

@@ -1,11 +1,11 @@
 ##
-# A special error as containers of errors inside [ Promise ]
-# @attr [ StandardError ] raw_exception raw execption raised
+# A special error as containers of errors inside [Promise]
+# @attr [StandardError] raw_exception raw execption raised
 class PromiseException < StandardError
   attr_reader :raw_exception
 
   # Init PromiseException
-  # @param [ StandardError ] raw_exception raw execption raised
+  # @param [StandardError] raw_exception raw execption raised
   def initialize(raw_exception)
     super(nil)
     @raw_exception = raw_exception

data/lib/midori/core_ext/safe_require.rb

@@ -1,7 +1,7 @@
 module Kernel
   # Raise error if Load Failed
-  # @param [ String ] file file to Load
-  # @param [ String ] prompt To prompt what when load error
+  # @param [String] file file to Load
+  # @param [String] prompt To prompt what when load error
   def safe_require(file, prompt)
     begin
       require file

data/lib/midori/extension/file.rb

@@ -3,13 +3,13 @@
 class Midori::File
   class << self
     # Same APIs as File.read
-    # @param [ Array ] args args of File.read
+    # @param [Array] args args of File.read
     def read(*args)
       await(defer{File.read(*args)})
     end
 
     # Same APIs as File.write
-    # @param [ Array ] args args of File.write
+    # @param [Array] args args of File.write
     def write(*args)
       await(defer{File.write(*args)})
     end

data/lib/midori/extension/ohm.rb

@@ -4,7 +4,7 @@ safe_require 'ohm', 'gem install ohm'
 # Midori Extension of ohm through meta programming Redic
 class Redic
   # Call a redis request asynchronously
-  # @param [ Array ] args args of Redic.call
+  # @param [Array] args args of Redic.call
   def call(*args)
     await(defer{
       @client.connect do

data/lib/midori/extension/postgres.rb

@@ -2,22 +2,22 @@ safe_require 'postgres-pr/message', 'gem install postgres-pr'
 
 ##
 # Midori Extension for Postgres Driver
-# @attr [ Integer ] connected Connection Status
+# @attr [Integer] connected Connection Status
 class Midori::Postgres
   attr_reader :connected
 
   # Init a Postgres Connection
-  # @param [ Array ] args args of EM.connect
+  # @param [Array] args args of EM.connect
   def initialize(*args)
     @connected = false
     @db = EM.connect(*args, EM::P::Postgres3)
   end
 
   # Connect the Postgres server
-  # @param [ String ] db_name database name
-  # @param [ String ] username username
-  # @param [ password ] password password
-  # @return [ nil ] nil
+  # @param [String] db_name database name
+  # @param [String] username username
+  # @param [password] password password
+  # @return [nil] nil
   def connect(db_name, username, password)
     await(Promise.new(->(resolve, _reject) {
       @db.connect(db_name, username, password).callback do |status|
@@ -28,8 +28,8 @@ class Midori::Postgres
   end
 
   # Make SQL query
-  # @param [ String ] sql sql query
-  # @return [ Midori::Postgres::Result ] query result
+  # @param [String] sql sql query
+  # @return [Midori::Postgres::Result] query result
   def query(sql)
     await(Promise.new(->(resolve, _reject) {
       begin
@@ -44,14 +44,14 @@ end
 
 ##
 # Postgres Result for Midori Postgres Driver Extension
-# @attr [ Array ] result result if success
-# @attr [ Array ] errors exceptions met
+# @attr [Array] result result if success
+# @attr [Array] errors exceptions met
 class Midori::Postgres::Result
   attr_reader :result, :errors
 
   # Init a Postgres Result
-  # @param [ Array ] result result if success
-  # @param [ Array ] errors exceptions met
+  # @param [Array] result result if success
+  # @param [Array] errors exceptions met
   def initialize(result, errors)
     @result = result
     @errors = errors

data/lib/midori/extension/redis.rb

@@ -5,15 +5,15 @@ safe_require 'em-hiredis', 'gem install em-hiredis'
 class Midori::Redis
 
   # Init a Redis Connection
-  # @param [ Array ] args args EM::Hiredis.connect
+  # @param [Array] args args EM::Hiredis.connect
   def initialize(*args)
     @connection = EM::Hiredis.connect(*args)
     @connection
   end
 
   # Call a redis request asynchronously
-  # @param [ String ] sys method name
-  # @param [ Array ] args args of the method calling
+  # @param [String] sys method name
+  # @param [Array] args args of the method calling
   def method_missing(sys, *args)
     await(Promise.new(->(resolve, _reject) {
       @connection.send(sys, *args).callback do |*ret_args|
@@ -23,7 +23,7 @@ class Midori::Redis
   end
 
   # Return raw pubsub mode
-  # @return [ EM::Hiredis::Pubsub ] raw pubsub
+  # @return [EM::Hiredis::Pubsub] raw pubsub
   def pubsub
     @connection.pubsub
   end

data/lib/midori/extension/sequel.rb

@@ -5,9 +5,9 @@ require 'sequel/adapters/postgres'
 # Midori Extension of sequel postgres through meta programming
 class Sequel::Postgres::Adapter
   # Call a sql request asynchronously
-  # @param [ String ] sql sql request
-  # @param [ Array ] args args to send
-  # @return [ Array ] sql query result
+  # @param [String] sql sql request
+  # @param [Array] args args to send
+  # @return [Array] sql query result
   def execute_query(sql, args)
     @db.log_connection_yield(sql, self, args) do
       args ? await(defer{async_exec(sql, args)}) : await(defer{async_exec(sql)})

data/lib/midori/middleware.rb

@@ -21,7 +21,7 @@ class Midori::Middleware
   end
 
   # Dynamically generate a method to use inside router
-  # @param [ Symbol ] name name of the method
+  # @param [Symbol] name name of the method
   # @yield the block to run
   def self.helper(name, &block)
     Midori::CleanRoom.class_exec do

data/lib/midori/request.rb

@@ -32,8 +32,8 @@ class Midori::Request
   end
 
   # Init an request with String data
-  # @param [ String ] data
-  # @return [ nil ] nil
+  # @param [String] data
+  # @return [nil] nil
   def parse(data)
     offset = @parser << data
     @body = data[offset..-1]

data/lib/midori/runner.rb

@@ -1,13 +1,13 @@
 ##
 # Abstract runner class to control instance of Midori Server
-# @attr [ String ] bind the address to bind
-# @attr [ Integer ] port the port to bind
+# @attr [String] bind the address to bind
+# @attr [Integer] port the port to bind
 class Midori::Runner
   attr_reader :bind, :port
 
   # Define status of a runner
-  # @param [ Class ] api inherited from [ Midori::API ]
-  # @param [ Class ] configure inherited from [ Midori::Configure ]
+  # @param [Class] api inherited from [Midori::API]
+  # @param [Class] configure inherited from [Midori::Configure]
   def initialize(api, configure = Midori::Configure)
     @logger = configure.logger
     @bind = configure.bind

data/lib/midori/sandbox.rb

@@ -9,17 +9,17 @@ class Midori::Sandbox
     end
 
     # Add a rule to Sandbox
-    # @param [ Class ] class_name the class to capture
-    # @param [ Proc ] block what to do when captured
-    # @return [ nil ] nil
+    # @param [Class] class_name the class to capture
+    # @param [Proc] block what to do when captured
+    # @return [nil] nil
     def add_rule(class_name, block)
       @handlers[class_name] = block
       nil
     end
 
     # Detect what to run with given error
-    # @param [ StandardError ] error the error captured
-    # @return [ nil ] nil
+    # @param [StandardError] error the error captured
+    # @return [nil] nil
     def capture(error)
       if @handlers[error.class].nil?
         @handlers[Midori::Exception::InternalError].call(error)
@@ -29,9 +29,9 @@ class Midori::Sandbox
     end
 
     # Run sandbox inside given clean room
-    # @param [ Midori::CleanRoom ] clean_room Clean room to run
-    # @param [ Proc ] function the block to run
-    # @return [ nil ] nil
+    # @param [Midori::CleanRoom] clean_room Clean room to run
+    # @param [Proc] function the block to run
+    # @return [nil] nil
     def run(clean_room, function, *args)
       begin
         function.to_lambda(clean_room).call(*args)

data/lib/midori/server.rb

@@ -2,13 +2,13 @@
 # Logic to EventMachine TCP Server, running inside +EM::Connection+
 module Midori::Server
   # @!attribute request
-  #   @return [ Midori::Request ] raw request
+  #   @return [Midori::Request] raw request
   # @!attribute api
-  #   @return [ Class ] inherited from Midori::API
+  #   @return [Class] inherited from Midori::API
   # @!attribute websocket
-  #   @return [ Midori::WebSocket ] defined websocket instance
+  #   @return [Midori::WebSocket] defined websocket instance
   # @!attribute eventsource
-  #   @return [ Midori::EventSource] defined eventsource instance
+  #   @return [Midori::EventSource] defined eventsource instance
   attr_accessor :request, :api, :websocket, :eventsource
 
   # Define server behaviour

data/lib/midori/version.rb

@@ -1,5 +1,5 @@
 # Midori Module
 module Midori
   # Current Version Code
-  VERSION = '0.1.7.1'.freeze
+  VERSION = '0.1.8'.freeze
 end

data/lib/midori/websocket.rb

@@ -1,22 +1,22 @@
 ##
 # This class provides methods for WebSocket connection instance.
-# @attr [ Array<Integer>, String ] msg message send from client
-# @attr [ Integer ] opcode operation code of WebSocket
-# @attr [ Hash ] events response for different event
-# @attr [ EM::Connection ] connection raw EventMachine connection
-# @attr [ Midori::Request ] request raw request
+# @attr [Array<Integer>, String] msg message send from client
+# @attr [Integer] opcode operation code of WebSocket
+# @attr [Hash] events response for different event
+# @attr [EM::Connection] connection raw EventMachine connection
+# @attr [Midori::Request] request raw request
 class Midori::WebSocket
   attr_accessor :msg, :opcode, :events, :connection, :request
 
   # Init a WebSocket instance with a connection
-  # @param [ EM::Connection ] connection raw EventMachine connection
+  # @param [EM::Connection] connection raw EventMachine connection
   def initialize(connection)
     @events = {}
     @connection = connection
   end
 
   # Decode raw data send from client
-  # @param [ StringIO ] data raw data
+  # @param [StringIO] data raw data
   def decode(data)
     # Fin and Opcode
     byte_tmp = data.getbyte
@@ -31,7 +31,7 @@ class Midori::WebSocket
   end
 
   # Decode masked message send from client
-  # @param [ StringIO ] data raw data
+  # @param [StringIO] data raw data
   def decode_mask(data)
     # Mask
     byte_tmp = data.getbyte
@@ -50,7 +50,7 @@ class Midori::WebSocket
   end
 
   # API definition for events
-  # @param [ Symbol ] event event name(open, message, close, ping, pong)
+  # @param [Symbol] event event name(open, message, close, ping, pong)
   # @yield what to do after event matched
   # @example
   #   websocket '/websocket' do |ws|
@@ -63,7 +63,7 @@ class Midori::WebSocket
   end
 
   # Send data
-  # @param [ Array<Integer>, String ] msg data to send
+  # @param [Array<Integer>, String] msg data to send
   def send(msg)
     output = []
     if msg.is_a?String
@@ -79,20 +79,20 @@ class Midori::WebSocket
   end
 
   # Send a Ping request
-  # @param [ String ] str string to send
+  # @param [String] str string to send
   def ping(str)
     heartbeat(0b10001001, str)
   end
 
   # Send a Pong request
-  # @param [ String ] str string to send
+  # @param [String] str string to send
   def pong(str)
     heartbeat(0b10001010, str)
   end
 
   # Ancestor of ping pong
-  # @param [ Integer ] method opcode
-  # @param [ String ] str string to send
+  # @param [Integer] method opcode
+  # @param [String] str string to send
   def heartbeat(method, str)
       raise Midori::Exception::PingPongSizeTooLarge if str.size > 125
       @connection.send_data [method, str.size, str].pack("CCA#{str.size}")

data/tutorial/README.md

@@ -0,0 +1,11 @@
+# Introduction
+
+## What is midori?
+
+Midori (pronounced /miːdɒliː/) is a **Ruby web framework** for building APIs, web pages and realtime web services. Midori is designed to provide **non-blocking** I/O operations without **callback hells** on web development. The core library is focused on network I/Os, and gives a very easy DSL to pick up and converting existed projects on. On the other hand, midori also officially provides extension libraries that could deal with file, database, cache, network requests and other I/O operations without blocking.
+
+If you want to know how midori compares to other libraries/frameworks, checkout out the [Compatison with Other Frameworks](meta/comparison_with_other_frameworks.md)
+
+## Note
+
+The official guide assumes intermediate level knowledge of Ruby and backend development. If you are totally new , it might not be the best idea to jump right into a framework as your first step - grasp the basics then come back! Prior experience with other frameworks like Rails helps, but is not required.

data/tutorial/SUMMARY.md

@@ -0,0 +1,28 @@
+# Summary
+
+## Essentials
+
+* [Introduction](README.md)
+* [Installation](essentials/installation.md)
+* [Getting Started](essentials/getting_started.md)
+* [Routing](essentials/routing.md)
+* [Request Handling](essentials/request_handling.md)
+* [Runner](essentials/runner.md)
+* [Middlewares](essentials/middlewares.md)
+* [Extensions](essentials/extensions.md)
+
+
+## Advanced
+
+- [Error Handling](advanced/error_handling.md)
+- [Request-Eval-Response Loop](advanced/rerl.md)
+- [Custom Extensions](advanced/custom_extensions.md)
+- [Scaling Project](advanced/scaling_project.md)
+- [Unit Testing](advanced/unit_testing.md)
+- [Deploying for Production](advanced/deploying_for_production.md)
+
+## Meta
+
+- [Comparison with Other Frameworks](meta/comparison_with_other_frameworks.md)
+- [Next Steps](meta/next_steps.md)
+- [Join the Midori Community](meta/join_the_midori_community.md)

data/tutorial/essentials/getting_started.md

@@ -0,0 +1,27 @@
+# Getting Started
+
+## Hello Midori
+
+midori is a [DSL](https://en.wikipedia.org/wiki/Domain-specific_language) for web and API development in Ruby  with minimal effort:
+
+```ruby
+# hello_midori.rb
+require 'midori'
+
+class HelloWorldAPI < Midori::API
+  get '/' do
+    'Ohayou Midori'
+  end
+end
+
+Midori::Runner.new(HelloWorldAPI).start
+```
+
+Run with
+
+```
+$ ruby hello_midori.rb
+```
+
+View at: http://127.0.0.1:8080 with your browser, if you see a page showing: **Ohayou Midori**. You've made your first application with midori.
+

data/tutorial/essentials/installation.md

@@ -0,0 +1,98 @@
+# Installation
+
+## Requirements
+
+Open up a command line prompt. Any commands prefaced with a dollar sign `$` should be run in the command line. Verify that you have a current version of Ruby installed:
+
+```
+ $ ruby -v
+ ruby 2.4.0p0
+```
+
+Generally, midori supports the following ruby interpreters:
+
+- Ruby (MRI) **>= 2.1.0**
+- JRuby >= **9.0.4.0**
+
+ For every version released, it would be tested and **officially ensured** in the following environments:
+
+- Ruby
+  - 2.1.0
+  - 2.2.6
+  - 2.3.3
+  - 2.4.0
+- JRuby
+  - 9.0.4.0, OpenJDK 7
+  - 9.0.4.0, OracleJDK 7
+  - 9.0.4.0, OracleJDK 8
+
+**Note: **
+
+- **For JRuby users, you may meet performance problem due to the issues of [Fiber implementation](https://github.com/jruby/jruby/wiki/DifferencesBetweenMriAndJruby#continuations-and-fibers) with JVM, which may [possibly improved](https://github.com/jruby/jruby/wiki/PerformanceTuning#enable-coroutine-based-fibers) in the future JRuby versions with JDK 9.**
+- **For macOS users, you may meet performance problem due to the issues of [EventMachine](https://github.com/heckpsi-lab/em-midori/issues/15). Very few people would use macOS in production, so this issue may not affect much, but we are still working hard on fixing it.**
+
+It's hard to say that if it is possible for running on other ruby implementations like Rubinius, if you're in favor of supporting more ruby implementations, you could open a ticket [here](https://github.com/heckpsi-lab/em-midori/issues), and we are glad to discuss it.
+
+## Install with RubyGems
+
+```
+$ gem install em-midori
+Successfully installed em-midori-0.1.7
+1 gem installed
+```
+
+To test whether it has installed properly, run:
+
+```
+$ ruby -r "midori" -e "class A < Midori::API;end;Midori::Runner.new(A).start"
+```
+
+If you see the following message, then everything now works fine.
+
+```
+Midori 0.1.7 is now running on 127.0.0.1:8080
+```
+
+## Use Bundler
+
+Example `Gemfile` of basic usage as following:
+
+```ruby
+source 'https://rubygems.org'
+gem 'bundler', '~> 1.0'
+gem 'em-midori', '~> 0.1', require: 'midori'
+```
+
+and then running:
+
+```
+$ bundle install
+```
+
+You could use
+
+```ruby
+require 'bundler'
+Bundler.require
+```
+
+in your entrance ruby file.
+
+To include built-in extensions of midori you could make your `Gemfile` like:
+
+```ruby
+source 'https://rubygems.org'
+gem 'bundler', '~> 1.0'
+gem 'em-midori', '~> 0.1', require: %w'midori midori/extension/sequel'
+```
+
+Using bunlder could make dependency management much easier, which helps a lot in scaling project. To learn more about bundler, you could see docs [here](http://bundler.io/docs.html). 
+
+## For Developers in China
+
+You may probably meet problems with rubygems due to unstable overseas internet connection issues in China. The most popular way to solve it is to use mirror provided by [RubyChina](https://gems.ruby-china.org/) or [TUNA](https://mirror.tuna.tsinghua.edu.cn/help/rubygems/) as your gem source. This may have some side effects in development, because there's a few minutes' delay in receiving gem updates.
+
+Alternatively, you could use proxy to connect the main repository directly to avoid the delay problem. But using proxy is a little too complex in production environment.
+
+Choose the solution better fits your requirements. Mixing the solutions like using proxy in development and using mirror in production is also a good choice.
+

data/tutorial/essentials/request_handling.md

@@ -0,0 +1,71 @@
+# Request Handling
+
+## Accessing the request object
+
+The incoming request object can be accessed from request level (filter, routes, error handlers) through the `request` method:
+
+```ruby
+class ExampleAPI < Midori::API
+  get '/' do
+    request.ip           # '127.0.0.1' client ip address
+    request.port         # '8080' client port
+    request.method       # 'GET'
+    request.path         # '/'
+    request.query_string # ''
+    request.header       # {} request header
+    request.body         # request body sent by the client
+    request.params       # {} params matched in router
+  end
+end
+```
+
+**Note (for sinatra users): **The `request.body` in modori is a `String` object but not a `StringIO` object.
+
+## Construct the response object
+
+Midori accepts the return value of the block as the response body by default.
+
+You could edit variable `status` and `header` to construct things other than body.
+
+You could also return a `Midori::Response` object as your response, which could override everything.
+
+```ruby
+class ExampleAPI < Midori::API
+  get '/case_0' do
+    'Hello'
+    # HTTP/1.1 200 OK
+    # Server: Midori/1.0
+    #
+    # Hello
+  end
+  
+  get '/case_1' do
+    status = 418
+    "I\'m a teapot"
+    # HTTP/1.1 418 I'm a teapot
+    # Server: Midori/1.0
+    #
+    # I'm a teapot
+  end
+  
+  get '/case_2' do
+    header['Example-Header'] = 'Example-Value'
+    'Hello'
+  end
+  # HTTP/1.1 200 OK
+  # Server: Midori/1.0
+  # Example-Header: Example-Value
+  #
+  # Hello
+  
+  get '/case_3' do
+    status = 202
+    header['Example-Header'] = 'Example-Value'
+    Midori::Response.new(200, {}, 'Hello')
+  end
+  # HTTP/1.1 200 OK
+  #
+  # Hello
+end
+```
+

data/tutorial/essentials/routing.md

@@ -0,0 +1,136 @@
+# Routing
+
+## Basic Usage
+
+Routes should be defined inside a class inherited from `Midori::API`. Midori doesn't support defining routes  globally like sinatra to avoid scope pollution, which affects a lot in scaling project.
+
+In midori, a route is an HTTP method with a URL-matching pattern. Each route is associated with a block:
+
+```ruby
+class ExampleAPI < Midori::API
+  get '/' do
+    #.. show something ..
+  end
+  
+  post '/' do
+    #.. create something ..
+  end
+  
+  put '/' do
+    #.. replace something ..
+  end
+  
+  delete '/' do
+    #.. annihilate something ..
+  end
+  
+  options '/' do
+    #.. appease something ..
+  end
+  
+  link '/' do
+    #.. affiliate something ..
+  end
+  
+  unlink '/' do
+    #.. separate something ..
+  end
+end
+```
+
+Routes are matched in the order they are defined. The first route that matches the request is invoked.
+
+Midori not only supports the methods above, it supports almostly every method provided in RFC standards. You could look it up in [API doc](http://www.rubydoc.info/gems/em-midori/Midori/API) for more details.
+
+## Params
+
+Routes patterns may include named parameters, accessible via the `request.params` hash:
+
+```ruby
+class ExampleAPI < Midori::API
+  get '/hello/:name' do
+    "Ohayou #{request.params['name']}"
+  end
+end
+```
+
+Route patterns may also include splat (or wildcard) parameters, accessible via the `request.params['splat']` array:
+
+```ruby
+class ExampleAPI < Midori::API
+  get '/say/*/to/*' do
+    # matches /say/hello/to/world
+    request.params['splat'] # => ["hello", "world"]
+  end
+
+  get '/download/*.*' do
+    # matches /download/path/to/file.xml
+    request.params['splat'] # => ["path/to/file", "xml"]
+  end
+end
+```
+
+Routes may also utilize query string:
+
+```ruby
+class ExampleAPI < Midori::API
+  get '/posts' do
+    # matches "GET /posts?title=foo&author=bar"
+    request.query_string # => title=foo&author=bar
+  end
+end
+```
+
+## WebSocket & EventSource
+
+`WebSocket` connection uses `GET` method in HTTP protocol, but indeed, it behaves totally different from `GET` requests. You don't need to care about the protocol details. In midori, you could easily manage websocket connections easily.
+
+Here's a chatroom example using websocket in midori:
+
+```ruby
+CONNECTION_POOL = []
+
+class ExampleAPI < Midori::API
+  websocket '/' do |ws|
+    ws.on :open do
+      ws.send 'Ohayo Midori'
+      CONNECTION_POOL << ws
+    end
+    
+    ws.on :message do |msg|
+      CONNECTION_POOL.map do |client|
+        client.send msg
+      end
+    end
+    
+    ws.on :close do
+      CONNECTION_POOL.delete(ws)
+      puts 'Oyasumi midori'
+    end
+  end
+end
+```
+
+midori also supports `EventSource ` connection as part of your route.
+
+Here's a chatroom example using eventsource in midori:
+
+```ruby
+CONNECTION_POOL = []
+
+class ExampleAPI < Midori::API
+  post '/pub' do
+    clients = CONNECTION_POOL.clone
+    CONNECTION_POOL.clear
+    # EventSource connection disconnects every time message sent, DO NOT reuse connection pool
+    clients.map do |client|
+      client.send request.body
+    end
+  end
+  
+  eventsource '/sub' do |es|
+    CONNECTION_POOL << es
+  end
+end
+```
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: em-midori
 version: !ruby/object:Gem::Version
-  version: 0.1.7.1
+  version: 0.1.8
 platform: ruby
 authors:
 - HeckPsi Lab
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-10 00:00:00.000000000 Z
+date: 2017-01-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: eventmachine
@@ -52,8 +52,8 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.6.1
-description: EM Midori is an EventMachine-based Web Framework written in pure Ruby,
-  providing high performance and proper abstraction.
+description: Midori is a Ruby Web Framework, providing high performance and proper
+  abstraction.
 email: business@heckpsi.com
 executables: []
 extensions: []
@@ -91,12 +91,35 @@ files:
 - lib/midori/server.rb
 - lib/midori/version.rb
 - lib/midori/websocket.rb
+- tutorial/README.md
+- tutorial/SUMMARY.md
+- tutorial/advanced/custom_extensions.md
+- tutorial/advanced/deploying_for_production.md
+- tutorial/advanced/error_handling.md
+- tutorial/advanced/rerl.md
+- tutorial/advanced/scaling_project.md
+- tutorial/advanced/unit_testing.md
+- tutorial/essentials/extensions.md
+- tutorial/essentials/getting_started.md
+- tutorial/essentials/installation.md
+- tutorial/essentials/middlewares.md
+- tutorial/essentials/request_handling.md
+- tutorial/essentials/routing.md
+- tutorial/essentials/runner.md
+- tutorial/meta/comparison_with_other_frameworks.md
+- tutorial/meta/join_the_midori_community.md
+- tutorial/meta/next_steps.md
 homepage: https://github.com/heckpsi-lab/em-midori
 licenses:
 - MIT
 metadata:
   issue_tracker: https://github.com/heckpsi-lab/em-midori/issues
-post_install_message: 
+post_install_message: "\n _____ _                       \n|  _  | |                      \n|
+  | | | |__   __ _ _   _  ___  \n| | | | '_ \\ / _` | | | |/ _ \\ \n\\ \\_/ / | |
+  | (_| | |_| | (_) |\n \\___/|_| |_|\\__,_|\\__, |\\___/ \n                    __/
+  |      \n                   |___/       \n           _     _            _ \n          (_)
+  \  | |          (_)\n _ __ ___  _  __| | ___  _ __ _ \n| '_ ` _ \\| |/ _` |/ _ \\|
+  '__| |\n| | | | | | | (_| | (_) | |  | |\n|_| |_| |_|_|\\__,_|\\___/|_|  |_|\n\n"
 rdoc_options: []
 require_paths:
 - lib
@@ -115,5 +138,5 @@ rubyforge_project:
 rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
-summary: An EventMachine Based Web Framework on Ruby
+summary: High performance ruby web framework
 test_files: []