em-midori 0.0.9.2 → 0.0.9.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a6692e87f5ea4a18142263b9562cb6028ebb2ade
-  data.tar.gz: f04594483fcfd0d6246b69eb3123ee921c909117
+  metadata.gz: 10e7c12fb4c851be82d6b1ebf1a5edbdfa8c3b77
+  data.tar.gz: 1e8c9cfe8c4cb0416f8e4f2f84ac2160e1825096
 SHA512:
-  metadata.gz: 50c92c8b8e94100969250047ca66cde9a48aa9f66c8d7cdde79027128d617309044f628c9f94f082d4b06409c2a7027fe477af69943bca4025b5b5cdc76e0328
-  data.tar.gz: c8af60ef0b79b5b3d06b8c8878dbcf9ef907df2a4a5b0ab95a75c1ab9d67a4d4abeeaff79d5e5af5edccccc1839af07034aecb35585359a8bc248a2cdd441e06
+  metadata.gz: a97cb0557f0865a4198415d9d72f3abf36b0b1929dda53b5fdcd0470c36d9ca99372da9deb3db60a510100052d36ae5e768456be6674d9ead089b4404d0f1e81
+  data.tar.gz: 7041791083c422d4b7929bcbb9fb97a43c37d82890333b61eba09a60fae44c355f2bd79c74c56b4dc44c0839d47e3793181f4e94b0a831a457899661218b35fd

data/lib/em-midori.rb

@@ -2,6 +2,7 @@ require 'digest/sha1'
 require 'stringio'
 require 'eventmachine'
 require 'fiber'
+require 'logger'
 
 require_relative 'em-midori/version'
 require_relative 'em-midori/string'

data/lib/em-midori/api.rb

@@ -3,165 +3,143 @@
 class Midori::API
   class << self
     # Add GET method as a DSL for route definition
-    # === Attributes
-    # * +path+ [+String+, +Regexp+] - Accepts as part of path in route definition.
-    # === Returns
-    # nil
-    # === Examples
-    # String as router
+    # @param [ String, Regexp ] 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
     #
-    # Regex as router
+    # @example Regex as router
     #   get /\/hello\/(.*?)/ do
     #      puts 'Hello World'
     #   end
     def get(path, &block) end
 
     # Add POST method as a DSL for route definition
-    # === Attributes
-    # * +path+ [+String+, +Regexp+] - Accepts as part of path in route definition.
-    # === Returns
-    # nil
-    # === Examples
-    # String as router
+    # @param [ String, Regexp ] 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
     #
-    # Regex as router
+    # @example Regex as router
     #   post /\/hello\/(.*?)/ do
     #      puts 'Hello World'
     #   end
     def post(path, &block) end
 
     # Add PUT method as a DSL for route definition
-    # === Attributes
-    # * +path+ [+String+, +Regexp+] - Accepts as part of path in route definition.
-    # === Returns
-    # nil
-    # === Examples
-    # String as router
+    # @param [ String, Regexp ] 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
     #
-    # Regex as router
+    # @example Regex as router
     #   put /\/hello\/(.*?)/ do
     #      puts 'Hello World'
     #   end
     def put(path, &block) end
 
     # Add DELETE method as a DSL for route definition
-    # === Attributes
-    # * +path+ [+String+, +Regexp+] - Accepts as part of path in route definition.
-    # === Returns
-    # nil
-    # === Examples
-    # String as router
+    # @param [ String, Regexp ] 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
     #
-    # Regex as router
+    # @example Regex as router
     #   delete /\/hello\/(.*?)/ do
     #      puts 'Hello World'
     #   end
     def delete(path, &block) end
 
     # Add OPTIONS method as a DSL for route definition
-    # === Attributes
-    # * +path+ [+String+, +Regexp+] - Accepts as part of path in route definition.
-    # === Returns
-    # nil
-    # === Examples
-    # String as router
+    # @param [ String, Regexp ] path Accepts as part of path in route definition
+    # @return [ nil ] nil
+    # @example String as router
     #   options '/' do
     #      puts 'Hello World'
     #   end
     #
-    # Regex as router
+    # @example Regex as router
     #   options /\/hello\/(.*?)/ do
     #      puts 'Hello World'
     #   end
     def options(path, &block) end
 
     # Add LINK method as a DSL for route definition
-    # === Attributes
-    # * +path+ [+String+, +Regexp+] - Accepts as part of path in route definition.
-    # === Returns
-    # nil
-    # === Examples
-    # String as router
+    # @param [ String, Regexp ] 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
     #
-    # Regex as router
+    # @example Regex as router
     #   link /\/hello\/(.*?)/ do
     #      puts 'Hello World'
     #   end
     def link(path, &block) end
 
     # Add UNLINK method as a DSL for route definition
-    # === Attributes
-    # * +path+ [+String+, +Regexp+] - Accepts as part of path in route definition.
-    # === Returns
-    # nil
-    # === Examples
-    # String as router
+    # @param [ String, Regexp ] 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
     #
-    # Regex as router
+    # @example Regex as router
     #   unlink /\/hello\/(.*?)/ do
     #      puts 'Hello World'
     #   end
     def unlink(path, &block) end
 
     # Add WEBSOCKET method as a DSL for route definition
-    # === Attributes
-    # * +path+ [+String+, +Regexp+] - Accepts as part of path in route definition.
-    # === Returns
-    # nil
-    # === Examples
-    # String as router
-    #   unlink '/' do
+    # @param [ String, Regexp ] 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
     #
-    # Regex as router
-    #   unlink /\/hello\/(.*?)/ do
+    # @example Regex as router
+    #   websocket /\/hello\/(.*?)/ do
     #      puts 'Hello World'
     #   end
     def websocket(path, &block) end
 
     # Add EVENTSOURCE method as a DSL for route definition
-    # === Attributes
-    # * +path+ [+String+, +Regexp+] - Accepts as part of path in route definition.
-    # === Returns
-    # nil
-    # === Examples
-    # String as router
-    #   unlink '/' do
+    # @param [ String, Regexp ] path Accepts as part of path in route definition
+    # @return [ nil ] nil
+    # @example String as router
+    #   eventsource '/' do
     #      puts 'Hello World'
     #   end
     #
-    # Regex as router
-    #   unlink /\/hello\/(.*?)/ do
+    # @example Regex as router
+    #   eventsource /\/hello\/(.*?)/ do
     #      puts 'Hello World'
     #   end
     def eventsource(path, &block) end
 
     # Implementation of route DSL
-    # === Attributes
-    # * +method+ [+String+] - HTTP method
-    # * +path+ [+String+, +Regexp+] - path definition
-    # * +block+ [+Proc+] - process to run when route matched
-    # === Returns
-    # 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)
       if path.class == String
         # Convert String to Regexp to provide performance boost (Precompiled Regexp)
@@ -173,10 +151,11 @@ class Midori::API
     end
 
     # Process after receive data from client
-    # === Attributes
-    # * +request+ [+Midori::Request+] - Http Raw Request
-    # === Returns
-    # [+Midori::Response+] - Http response
+    # @param request [ Midori::Request ] Http Raw Request
+    # @param connection [ EM::Connection ] A connection created by EventMachine
+    # @yield what to run when route matched
+    # @return [ Midori::Response ] Http Response
+    # @raise [ Midori::Error::NotFound ] If no route matched
     def receive(request, connection = nil)
       @route.each do |route|
         matched = match(route.method, route.path, request.method, request.path)
@@ -188,8 +167,6 @@ class Midori::API
         end
         middlewares.each { |middleware| request = middleware.before(request) }
         clean_room = Midori::CleanRoom.new(request, middlewares, body_accept)
-        @helpers ||= []
-        @helpers.map { |block| clean_room.instance_exec(&block) }
         if request.websocket?
           # Send 101 Switching Protocol
           connection.send_data Midori::Response.new(101, websocket_header(request.header['Sec-WebSocket-Key']), '')
@@ -211,15 +188,13 @@ class Midori::API
     end
 
     # Match route with given definition
-    # === Attributes
-    # * +method+ [+String+] - Accepts an HTTP/1.1 method like GET POST PUT ...
-    # * +path+ [+Regexp+] - Precompiled route definition.
-    # * +request+ [+String+] - HTTP Request String
-    # === Returns
-    # if not matched returns false
-    #
-    # else returns an array of parameter string matched
-    # === Examples
+    # @param [ String ] method Accepts an HTTP/1.1 method like GET POST PUT ...
+    # @param [ Regexp ] path Precompiled route definition.
+    # @param [ String ] request_method HTTP Request Method
+    # @param [ String ] request_path HTTP Request Path
+    # @return [ Array ] matched parameters
+    # @return [ Boolean ] false if not matched
+    # @example match a route
     #   match('GET', /^\/user\/(.*?)\/order\/(.*?)$/, '/user/foo/order/bar') # => ['foo', 'bar']
     def match(method, path, request_method, request_path)
       if request_method == method
@@ -232,11 +207,9 @@ class Midori::API
     end
 
     # Convert String path to its Regexp equivalent
-    # === Attributes
-    # * +path+ [+String+] - String route definition
-    # === Returns
-    # Regexp equivalent
-    # === Examples
+    # @param [ String ] path String route definition
+    # @return [ Regexp ] Regexp equivalent
+    # @example
     #   convert_route('/user/:id/order/:order_id') # => Regexp
     def convert_route(path)
       path = '^' + path
@@ -246,13 +219,21 @@ class Midori::API
       Regexp.new path
     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)
+      CleanRoom.class_exec { middleware.helper }
       @middleware = [] if @middleware.nil?
       @middleware << middleware
       @body_accept = middleware.body_accept
+      nil
     end
 
+    # Return websocket header with given key
+    # @param [String] key 'Sec-WebSocket-Key' in request header
+    # @return [Hash] header
     def websocket_header(key)
       {
         'Upgrade' => 'websocket',
@@ -261,15 +242,17 @@ class Midori::API
       }
     end
 
+    # Helper block for defining methods in APIs
+    # @yield define what to run in CleanRoom
     def helper(&block)
-      @helpers = [] if @helpers.nil?
-      @helpers << block
+      Midori::CleanRoom.class_exec(&block)
     end
   end
 
   private_class_method :add_route
 
-  METHODS = %w(get post put delete options link unlink websocket eventsource).freeze # :nodoc:
+  # Constants of supported methods in route definition
+  METHODS = %w(get post put delete options link unlink websocket eventsource).freeze
 
   # Magics to fill DSL methods through dynamically class method definition
   METHODS.each do |method|

data/lib/em-midori/clean_room.rb

@@ -1,5 +1,14 @@
+##
+# This class is used to be sandbox of requests processing.
+# @attr [Fixnum] code 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::Midlleware+
+# @attr [Midori::Request] request HTTP request
 class Midori::CleanRoom
   attr_accessor :code, :header, :body, :request
+  # @param [Midori::Request] request HTTP request
+  # @param [Array<Midori::Middleware>] middleware middlewares to run
+  # @param [Array<Class>] body_accept what class for body could last middleware accept by default
   def initialize(request, middleware = [], body_accept = [String])
     @status = 200
     @header = Midori::Const::DEFAULT_HEADER.clone
@@ -9,15 +18,23 @@ class Midori::CleanRoom
     @body_accept = body_accept
   end
 
+  # Genenrate response from variables inside +Midori::CleanRoom+
+  # @return [Midori::Response] midori response
   def raw_response
     Midori::Response.new(@status, @header, @body)
   end
 
+  # Add a middleware to a specific route
+  # @param [Class] middleware inherited form +Midori::Middleware+ class
+  # @param [Array<Object>] args for middleware initialize
+  # @return [nil] nil
   def use(middleware, *args)
     middleware = middleware.new(*args)
+    middleware.helper
     @middleware = [] if @middleware.nil?
     @middleware << middleware
     @body_accept.replace middleware.body_accept
     @request = middleware.before(request)
+    nil
   end
 end

data/lib/em-midori/const.rb

@@ -1,4 +1,7 @@
+##
+# Module for store Midori Consts
 module Midori::Const
+  # Hash table for converting numbers to HTTP/1.1 status code line
   STATUS_CODE = {
     100 => '100 Continue',
     101 => '101 Switching Protocols',
@@ -32,6 +35,7 @@ module Midori::Const
     415 => '415 Unsupported Media Type',
     416 => '416 Requested range not satisfiable',
     417 => '417 Expectation Failed',
+    451 => '451 ',
     500 => '500 Internal Server Error',
     501 => '501 Not Implemented',
     502 => '502 Bad Gateway',
@@ -42,10 +46,12 @@ module Midori::Const
   STATUS_CODE.default = '500 Internal Server Error'
   STATUS_CODE.freeze
 
+  # Default header for Basic HTTP response
   DEFAULT_HEADER = {
     'Server' => "Midori/#{Midori::VERSION}"
   }
 
+  # Default header for Evenrsource response
   EVENTSOURCE_HEADER = {
     'Content-Type' => 'text-event-stream',
     'Cache-Control' => 'no-cache',

data/lib/em-midori/define_class.rb

@@ -1,16 +1,29 @@
-module Kernel #:nodoc:
+##
+# Meta-programming Kernel for Syntactic Sugars
+module Kernel
   # This method is implemented to dynamically generate class with given name and template.
   # Referenced from {Ruby China}[https://ruby-china.org/topics/17382]
+  # @param [String] name name of class
+  # @param [Class] ancestor class to be inherited
+  # @yield inner block to be inserted into class
+  # @return [Class] the class defined
   def define_class(name, ancestor = Object)
     Object.const_set(name, Class.new(ancestor))
     Object.const_get(name).class_eval(&Proc.new) if block_given?
     Object.const_get(name)
   end
 
+  # Define a batch of error handler with given name
+  # @param [Array<Symbol>] args names to be defined
+  # @return [nil] nil
+  # @example
+  #   define_error(:foo_error, :bar_error) 
+  #   => nil, FooError < StandardError and BarError < StandardError would be defined
   def define_error(*args)
     args.each do |arg|
       class_name = arg.to_s.split('_').collect(&:capitalize).join
       define_class(class_name, StandardError)
     end
+    nil
   end
 end

data/lib/em-midori/em_midori.rb

@@ -1,18 +1,27 @@
-require 'logger'
-
+##
+# The main module of Midori
 module Midori
-  @logger = ::Logger.new(StringIO.new)
-
-  def self.run(api = Midori::API, ip = nil, port = nil, logger = ::Logger.new(STDOUT))
-    ip ||= '127.0.0.1'
-    port ||= 8081
+  @logger = ::Logger.new(STDOUT)
+  # Start Midori Server instance
+  # @note This is an async method, but no callback
+  # @param [Class] api Inherit from +Midori::API+
+  # @param [String] ip The ip address to bind
+  # @param [Fixnum] port Port number
+  # @param [Logger] logger Ruby logger
+  # @return [nil] nil
+  def self.run(api = Midori::API, ip = '127.0.0.1', port = 8081, logger = ::Logger.new(STDOUT))
     @logger = logger
     EventMachine.run do
       @logger.info "Midori #{Midori::VERSION} is now running on #{ip}:#{port}".blue
       @midori_server = EventMachine.start_server ip, port, Midori::Server, api, logger
     end
+    nil
   end
 
+  # Stop Midori Server instance
+  # @note This is an async method, but no callback
+  # @return [Boolean] [true] stop successfully
+  # @return [Boolean] [false] nothing to stop
   def self.stop
     if @midori_server.nil?
       @logger.error 'Midori Server has NOT been started'.red

data/lib/em-midori/error.rb

@@ -1,10 +1,20 @@
+##
+# This module store errors to be handled in Midori
 module Midori::Error
+  # No route matched
   class NotFound < StandardError; end
+  # Midori doesn't support continuous frame of WebSockets yet
   class ContinuousFrame < StandardError; end
+  # WebSocket OpCode not defined in RFC standards
   class OpCodeError < StandardError; end
+  # Websocket request not masked
   class NotMasked < StandardError; end
+  # Websocket frame has ended
   class FrameEnd < StandardError; end
+  # Websocket Ping Pong size too large
   class PingPongSizeTooLarge < StandardError; end
+  # Not sending String in EventSource
   class EventSourceTypeError < StandardError; end
+  # Insert a not middleware class to middleware list
   class MiddlewareError < StandardError; end
 end

data/lib/em-midori/eventsource.rb

@@ -1,10 +1,16 @@
+##
+# This class provides methods for EventSource connection instance.
+# @attr [EM::Connection] connection the connection instance of EventMachine
 class Midori::EventSource
   attr_accessor :connection
 
+  # @param [EM::Connection] connection the connection instance of EventMachine
   def initialize(connection)
     @connection = connection
   end
 
+  # Send data and close the connection
+  # @param [String] data data to be sent
   def send(data)
     raise Midori::Error::EventSourceTypeError unless data.is_a?String
     @connection.send_data(data.split("\n").map {|str| "data: #{str}\n"}.join + "\n")

data/lib/em-midori/middleware.rb

@@ -1,15 +1,32 @@
+##
+# Ancestor of all middlewares
 class Midori::Middleware
+  # Init a middleware
   def initialize
   end
 
+  # run before processing a request
+  # @param [Midori::Request] request raw request
+  # @return [Midori::Request] request to be further processed
   def before(request)
     request
   end
 
+  # run after processing a request
+  # @param [Midori::Request] _request raw request
+  # @param [Midori::Response] response raw response
+  # @return [Midori::Response] response to be further processed
   def after(_request, response)
     response
   end
 
+  # code to be inserted inside CleanRoom
+  # @return [nil] nil
+  def helper
+  end
+
+  # Acceptable body
+  # @return [Array<Class>] array of acceptable type's class
   def body_accept
     [String]
   end

data/lib/em-midori/promise.rb

@@ -1,30 +1,52 @@
+##
+# Meta-programming String for Syntactic Sugars
 # Referenced from {Qiita}[http://qiita.com/south37/items/99a60345b22ef395d424]
 class Promise
+  # @param [Proc] callback an async method
   def initialize(callback)
     @callback = callback
   end
 
+  # Define what to do after a method callbacked
+  # @param [Proc] resolve what if callbacked
+  # @param [Proc] reject what if callback failed
+  # @return [nil] nil
   def then(resolve = ->() {}, reject = ->() {})
     @callback.call(resolve, reject)
   end
 end
 
-def async_internal(fiber)
-  chain = ->(result) {
-    return if result.class != Promise
-    result.then(->(val) {
-      chain.call(fiber.resume(val))
-    })
-  }
-  chain.call(fiber.resume)
-end
+module Kernel
+  # Logic dealing of async method
+  # @param [Fiber] fiber a fiber to call
+  def async_internal(fiber)
+    chain = lambda do |result|
+      return if result.class != Promise
+      result.then(lambda do |val|
+        chain.call(fiber.resume(val))
+      end)
+    end
+    chain.call(fiber.resume)
+  end
 
-def async(method_name, &block)
-  define_singleton_method method_name, ->(*args) {
-    async_internal(Fiber.new {block.call(*args)})
-  }
-end
+  # Define an async method
+  # @param [Symbol] method_name method name
+  # @yield async method
+  # @example
+  #   async :hello do 
+  #     puts 'Hello'
+  #   end
+  def async(method_name)
+    define_singleton_method method_name, ->(*args) {
+      async_internal(Fiber.new { yield(*args) })
+    }
+  end
 
-def await(promise)
-  Fiber.yield promise
+  # Block the I/O to wait for async method response
+  # @param [Promise] promise promise method
+  # @example
+  #   result = await SQL.query('SELECT * FROM hello')
+  def await(promise)
+    Fiber.yield promise
+  end
 end

data/lib/em-midori/request.rb

@@ -1,8 +1,19 @@
+##
+# Request class for midori
+# @attr [String] ip client ip address
+# @attr [Fixnum] port client port
+# @attr [String] protocol protocol version of HTTP request
+# @attr [String] path request path
+# @attr [String] query_string request query string
+# @attr [Hash] header request header
+# @attr [String] body request body
+# @attr [Boolean] parsed whether the request parsed
 class Midori::Request
   attr_accessor :ip, :port,
                 :protocol, :method, :path, :query_string,
                 :header, :body, :parsed
 
+  # Init Request
   def initialize
     @parsed = false
     @is_websocket = false
@@ -10,8 +21,7 @@ class Midori::Request
   end
 
   # Init an request with StringIO data
-  # === Attributes
-  # * +data+ [+StringIO+] - Request data
+  # @param [StringIO+] data Request data
   def parse(data)
     @header = {}
 
@@ -46,14 +56,20 @@ class Midori::Request
     @parsed = true
   end
 
+  # Syntatic sugur for whether a request is parsed
+  # @return [Boolean] parsed or not
   def parsed?
     @parsed
   end
 
+  # Syntatic sugur for whether a request is a websocket request
+  # @return [Boolean] websocket or not
   def websocket?
     @is_websocket
   end
 
+  # Syntatic sugur for whether a request is an eventsource request
+  # @return [Boolean] eventsource or not
   def eventsource?
     @is_eventsource
   end

data/lib/em-midori/response.rb

@@ -1,18 +1,30 @@
+##
+# Class for midori response
+# @attr [String] HTTP response status
+# @attr [Hash] HTTP response header
+# @attr [String] HTTP response body
 class Midori::Response
   attr_accessor :status, :header, :body
 
+  # @param [Fixnum] code HTTP response code
+  # @param [Hash] header HTTP response header
+  # @param [String] body HTTP response body
   def initialize(code = 200, header = Midori::Const::DEFAULT_HEADER.clone, body = '')
     @status = Midori::Const::STATUS_CODE[code]
     @header = header
     @body = body
   end
 
+  # Generate header string from hash
+  # @return [String] generated string
   def generate_header
     @header.map do |key, value|
       "#{key}: #{value}\r\n"
     end.join
   end
 
+  # Convert response to raw string
+  # @return [String] generated string
   def to_s
     "HTTP/1.1 #{@status}\r\n#{generate_header}\r\n#{@body}"
   end

data/lib/em-midori/route.rb

@@ -1,5 +1,14 @@
+##
+# Class for Midori route
+# @attr [String] method HTTP method
+# @attr [Regexp] path regex to match
+# @attr [Proc] function what to do after matched
 class Midori::Route
   attr_accessor :method, :path, :function
+
+  # @param [String] method HTTP method
+  # @param [Regexp] path regex to match
+  # @param [Proc] function what to do after matched
   def initialize(method, path, function)
     @method = method
     @path = path

data/lib/em-midori/server.rb

@@ -1,6 +1,14 @@
+##
+# Logics to EventMachine TCP Server, running inside +EM::Connection+
+# @attr [Midori::Request] request
+# @attr [Class] api inherited from Midori::API
+# @attr [Midori::WebSocket] websocket websocket instance
+# @attr [Midori::EventSource] eventsource eventsource instance
 module Midori::Server
   attr_accessor :request, :api, :websocket, :eventsource
 
+  # @param [Class] api inherited from Midori::API
+  # @param [Logger] logger global logger
   def initialize(api, logger)
     @api = api
     @logger = logger
@@ -9,6 +17,8 @@ module Midori::Server
     @eventsource = Midori::EventSource.new(self)
   end
 
+  # Logics of receiving data
+  # @param [String] data raw data
   def receive_data(data)
     ->() { async_internal(Fiber.new do
       start_time = Time.now
@@ -26,6 +36,8 @@ module Midori::Server
     end) }.call
   end
 
+  # Logics of receiving new request
+  # @param [String] data raw data
   def receive_new_request(data)
     begin
       @request.parse(data)
@@ -44,6 +56,8 @@ module Midori::Server
     end
   end
 
+  # Logics of receiving WebSocket request
+  # @param [String] data raw data
   def websocket_request(data)
     @websocket.decode(data)
     case @websocket.opcode
@@ -69,6 +83,9 @@ module Midori::Server
     close_connection_after_writing
   end
 
+  # To call a websocket event if it exist
+  # @param [Symbol] event event name
+  # @param [Array] args arg list
   def call_event(event, args = [])
     (-> { @websocket.instance_exec(*args, &@websocket.events[event]) }.call) unless @websocket.events[event].nil?
   end

data/lib/em-midori/string.rb

@@ -1,20 +1,28 @@
+##
+# Meta-programming String for Syntactic Sugars
 class String
+  # @param [Fixnum] color_code ANSI color code
+  # @return [String] colored string
   def colorize(color_code)
     "\e[#{color_code}m#{self}\e[0m"
   end
 
+  # color the string with red color
   def red
     colorize(31)
   end
 
+  # color the string with green color
   def green
     colorize(32)
   end
-
+  
+  # color the string with yellow color
   def yellow
     colorize(33)
   end
 
+  # color the string with blue color
   def blue
     colorize(34)
   end

data/lib/em-midori/version.rb

@@ -1,3 +1,4 @@
 module Midori
-  VERSION = '0.0.9.2'.freeze
+  # Current Version Code
+  VERSION = '0.0.9.3'.freeze
 end

data/lib/em-midori/websocket.rb

@@ -1,13 +1,20 @@
 ##
 # This class provides methods for WebSocket connection instance.
+# @attr [Array<Fixnum>, String] msg message send from client
+# @attr [Fixnum] opcode operation code of WebSocket
+# @attr [Hash] events response for different event
+# @attr [EM::Connection] connection raw EventMachine connection
 class Midori::WebSocket
   attr_accessor :msg, :opcode, :events, :connection
 
+  # @param [EM::Connection] connection raw EventMachine connection
   def initialize(connection)
     @events = {}
     @connection = connection
   end
 
+  # Decode raw data send from client
+  # @param [String] data raw data
   def decode(data)
     # Fin and Opcode
     byte_tmp = data.getbyte
@@ -21,6 +28,8 @@ class Midori::WebSocket
     decode_mask(data)
   end
 
+  # Decode masked message send from client
+  # @param [String] data raw data
   def decode_mask(data)
     # Mask
     byte_tmp = data.getbyte
@@ -38,10 +47,21 @@ class Midori::WebSocket
     #  data.bytes {|byte| puts byte.to_s(16)}
   end
 
+  # API definition for events
+  # @param [Symbol] event event name(open, message, close, ping, pong)
+  # @yield what to do after event matched
+  # @example
+  #   websocket '/websocket' do |ws|
+  #     ws.on :message do |msg|
+  #       puts msg
+  #     end
+  #   end
   def on(event, &block) # open, message, close, ping, pong
     @events[event] = block
   end
 
+  # Send data
+  # @param [Array<Fixnum>, String] msg data to send
   def send(msg)
     output = []
     if msg.is_a?String
@@ -56,19 +76,27 @@ class Midori::WebSocket
     end
   end
 
+  # Send a Ping request
+  # @param [String] str string to send
   def ping(str)
     heartbeat(0b10001001, str)
   end
 
+  # Send a Pong request
+  # @param [String] str string to send
   def pong(str)
     heartbeat(0b10001010, str)
   end
 
+  # Ancestor of ping pong
+  # @param [Fixnum] method opcode
+  # @param [String] str string to send
   def heartbeat(method, str)
       raise Midori::Error::PingPongSizeTooLarge if str.size > 125
       @connection.send_data [method, str.size, str].pack("CCA#{str.size}")
   end
 
+  # Close a websocket connection
   def close
     raise Midori::Error::FrameEnd
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: em-midori
 version: !ruby/object:Gem::Version
-  version: 0.0.9.2
+  version: 0.0.9.3
 platform: ruby
 authors:
 - HeckPsi Lab
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-21 00:00:00.000000000 Z
+date: 2016-10-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: eventmachine