midori.rb 0.4.3

data/lib/midori/connection.rb

@@ -0,0 +1,59 @@
+##
+# States of a connection
+class Midori::Connection
+  include Midori::Server
+
+  # @!attribute data
+  #   @return [String] string buffer of data to send
+  attr_accessor :data
+
+  # Init Connection with socket
+  # @param [IO] socket raw socket
+  def initialize(socket)
+    @registered = false
+    @socket = socket
+    @monitor = nil
+    @close_flag = false
+    @data = ''
+    listen(socket)
+  end
+
+  # Register events of connection
+  # @param [IO] socket raw socket
+  def listen(socket)
+    EventLoop.register(socket, :rw) do |monitor|
+      @monitor = monitor
+      if monitor.readable?
+        receive_data(monitor)
+      end
+      if monitor.writable?
+        if !@data == ''
+          # :nocov:
+          # Leave for corner cases
+          monitor.io.write_nonblock(@data)
+          @data = ''
+          # :nocov:
+        elsif @close_flag
+          close_connection
+        end
+      end
+    end
+  end
+
+  # Send message to client
+  # @param [String] data data to send
+  def send_data(data)
+    @monitor.writable? ? @socket.write_nonblock(data) : @data << data
+  end
+
+  # Close the connection
+  def close_connection
+    EventLoop.deregister @socket
+    @socket.close
+  end
+
+  # Close the connection after writing
+  def close_connection_after_writing
+    @close_flag = true
+  end
+end

data/lib/midori/const.rb

@@ -0,0 +1,118 @@
+##
+# Module for store Midori Const
+module Midori::Const
+  # Hash table for converting numbers to HTTP/1.1 status code line
+  STATUS_CODE = {
+    100 => '100 Continue',
+    101 => '101 Switching Protocols',
+    102 => '102 Processing', # RFC 2518
+    200 => '200 OK',
+    201 => '201 Created',
+    202 => '202 Accepted',
+    203 => '203 Non-Authoritative Information',
+    204 => '204 No Content',
+    205 => '205 Reset Content',
+    206 => '206 Partial Content', # RFC 7233
+    207 => '207 Multi-Status', # RFC 4918
+    208 => '208 Already Reported', # RFC 5842
+    226 => '226 IM Used', # RFC 3229
+    300 => '300 Multiple Choices',
+    301 => '301 Moved Permanently',
+    302 => '302 Found',
+    303 => '303 See Other',
+    304 => '304 Not Modified', # RFC 7232
+    305 => '305 Use Proxy',
+    307 => '307 Temporary Redirect',
+    308 => '308 Permanent Redirect', # RFC 7538
+    400 => '400 Bad Request',
+    401 => '401 Unauthorized', # RFC 7235
+    402 => '402 Payment Required',
+    403 => '403 Forbidden',
+    404 => '404 Not Found',
+    405 => '405 Method Not Allowed',
+    406 => '406 Not Acceptable',
+    407 => '407 Proxy Authentication Required', # RFC 7235
+    408 => '408 Request Time-out',
+    409 => '409 Conflict',
+    410 => '410 Gone',
+    411 => '411 Length Required',
+    412 => '412 Precondition Failed', # RFC 7232
+    413 => '413 Payload Too Large', # RFC 7231
+    414 => '414 URI Too Long', # RFC 7231
+    415 => '415 Unsupported Media Type',
+    416 => '416 Range Not Satisfiable',
+    417 => '417 Expectation Failed', # RFC 2324
+    418 => '418 I\'m a teaport', # RFC 2324
+    421 => '421 Misdirected Request', # RFC 7540
+    422 => '422 Unprocessable Entity', # RFC 4918
+    423 => '423 Locked', # RFC 4918
+    424 => '424 Failed Dependency', # RFC 4918
+    426 => '426 Upgrade Required',
+    428 => '428 Precondition Required', # RFC 6585
+    429 => '429 Too Many Requests', # RFC 6585
+    431 => '431 Request Header Fields Too Large', # RFC 6585
+    451 => '451 Unavailable For Legal Reasons',
+    500 => '500 Internal Server Error',
+    501 => '501 Not Implemented',
+    502 => '502 Bad Gateway',
+    503 => '503 Service Unavailable',
+    504 => '504 Gateway Time-out',
+    505 => '505 HTTP Version not supported',
+    506 => '506 Variant Also Negotiates', # RFC 2295
+    507 => '507 Insufficient Storage', # RFC 4918
+    508 => '508 Loop Detected', # RFC 5842
+    510 => '510 Not Extended', # RFC 2774
+    511 => '511 Network Authentication Required', # RFC 6585
+  }
+  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 EventSource response
+  EVENTSOURCE_HEADER = {
+    'Content-Type' => 'text-event-stream',
+    'Cache-Control' => 'no-cache',
+    'Connection' => 'keep-alive'
+  }
+
+  # Default header for WebSocket response
+  WEBSOCKET_HEADER = {
+    'Upgrade' => 'websocket',
+    'Connection' => 'Upgrade'
+  }
+
+  # Array of Route Methods
+  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/configurable.rb

@@ -0,0 +1,33 @@
+##
+# Modified from Sinatra
+# Provide flexible configuration for Midori Server
+module Configurable
+  # Sets an option to the given value.
+  # @param [Symbol] option the name of config
+  # @param [Object] value value to the name
+  # @param [Boolean] read_only Generate option= method or not
+  # @return [nil] nil
+  def set(option, value = (not_set = true), read_only = false)
+    raise ArgumentError if not_set
+
+    setter = proc { |val| set option, val }
+    getter = proc { value }
+
+    define_singleton("#{option}=", setter) unless read_only
+    define_singleton(option, getter)
+    define_singleton("#{option}?", "!!#{option}") unless method_defined? "#{option}?"
+
+    self
+  end
+
+  # Dynamically defines a method on settings.
+  # @param [String] name method name
+  # @param [Proc] content method content
+  # @return [nil] nil
+  private def define_singleton(name, content = Proc.new)
+    singleton_class.class_eval do
+      undef_method(name) if method_defined? name
+      String === content ? class_eval("def #{name}() #{content}; end") : define_method(name, &content)
+    end
+  end
+end

data/lib/midori/core_ext/define_class.rb

@@ -0,0 +1,29 @@
+##
+# 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/midori/core_ext/proc.rb

@@ -0,0 +1,13 @@
+##
+# Meta-programming Proc for Syntactic Sugars
+class Proc
+  # 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)
+    instance.define_singleton_method(:_, &self)
+    instance.method(:_).to_proc
+  end
+end

data/lib/midori/core_ext/string.rb

@@ -0,0 +1,29 @@
+##
+# Meta-programming String for Syntactic Sugars
+class String
+  # @param [Integer] 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
+end

data/lib/midori/env.rb

@@ -0,0 +1,18 @@
+module Midori
+  # @return [String] midori environment
+  def self.env
+    ENV['MIDORI_ENV'] || 'development'
+  end
+end
+
+class String
+  # @return [TrueClass | FalseClass] if string is equal to production
+  def production?
+    self == 'production'
+  end
+
+  #@return [TrueClass | FalseClass] if string is equal to development
+  def development?
+    self == 'development'
+  end
+end

data/lib/midori/eventsource.rb

@@ -0,0 +1,20 @@
+##
+# This class provides methods for EventSource connection instance.
+# @attr [Midori::Connection] connection the connection instance of EventMachine
+class Midori::EventSource
+  attr_accessor :connection
+
+  # Init a EventSource instance with a connection
+  # @param [Midori::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::Exception::EventSourceTypeError unless data.is_a? String
+    @connection.send_data(data.split("\n").map {|str| "data: #{str}\n"}.join + "\n")
+    @connection.close_connection_after_writing
+  end
+end

data/lib/midori/exception.rb

@@ -0,0 +1,22 @@
+##
+# This module store errors to be handled inside Midori
+module Midori::Exception
+  # No route matched
+  class NotFound < StandardError; end
+  # Internal Error
+  class InternalError < 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/midori/logger.rb

@@ -0,0 +1,15 @@
+module Midori
+  class << self
+    # Return current logger midori is using
+    # @return [Logger] the current logger midori is using
+    def logger
+      @logger ||= ::Logger.new(STDOUT)
+    end
+
+    # Return midori's logger
+    # @param [Logger] logger set midori logger
+    def logger=(logger)
+      @logger = logger
+    end
+  end
+end

data/lib/midori/middleware.rb

@@ -0,0 +1,31 @@
+##
+# 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
+
+  # Dynamically generate a method to use inside router
+  # @param [Symbol] name name of the method
+  # @yield the block to run
+  def self.helper(name, &block)
+    Midori::CleanRoom.class_exec do
+      define_method(name, &block)
+    end
+  end
+end

data/lib/midori/request.rb

@@ -0,0 +1,115 @@
+##
+# Request class for midori
+# @attr [String] ip client ip address
+# @attr [Integer] port client port
+# @attr [String] protocol protocol version of HTTP request
+# @attr [Symbol] method HTTP method
+# @attr [String] path request path
+# @attr [Hash] query_param parameter parsed from query string
+# @attr [String | nil] query_string request query string
+# @attr [Hash] header request header
+# @attr [String] body request body
+# @attr [Hash] cookie cookie hash coming from request
+# @attr [Boolean] parsed whether the request header parsed
+# @attr [Boolean] body_parsed whether the request body parsed
+# @attr [Hash] params params in the url
+class Midori::Request
+  attr_accessor :ip, :port,
+                :protocol, :method, :path, :query_params, :query_string,
+                :header, :body, :parsed, :body_parsed, :params, :cookie
+
+  # Init Request
+  def initialize
+    @header = {}
+    @parsed = false
+    @body_parsed = false
+    @is_websocket = false
+    @is_eventsource = false
+    @parser = Http::Parser.new
+    @params = {}
+    @query_params = Hash.new(Array.new)
+    @cookie = {}
+    @body = ''
+    @parser.on_headers_complete = proc do
+      @protocol = @parser.http_version
+      @method = @parser.http_method
+      @path = @parser.request_url
+      @header = @parser.headers
+
+      @query_string = @path.match(/\?(.*?)$/)
+      unless @query_string.nil?
+        @query_string = @query_string[1]
+        @query_params = CGI::parse(@query_string)
+      end
+
+      @cookie = CGI::Cookie.parse(@header['Cookie']) unless @header['Cookie'].nil?
+      @path.gsub!(/\?(.*?)$/, '')
+      @method = @method.to_sym
+      @parsed = true
+      :stop
+    end
+  end
+
+  # Init an request with String data
+  # @param [String] data
+  # @return [nil] nil
+  def parse(data)
+    # Call parser if header not parsed
+    if @parsed
+      @body += data
+    else
+      offset = @parser << data
+      @body += data[offset..-1] if @parsed
+    end
+
+    # Set body parsed if body reaches content length
+    if @parsed && (@header['Content-Length'].to_i || 0) <= @body.bytesize
+      @body_parsed = true
+      pre_proceed
+    end
+    nil
+  end
+
+  # Preproceed the request after parsed
+  # @return [nil] nil
+  def pre_proceed
+    # Deal with WebSocket
+    if @header['Upgrade'] == 'websocket' && @header['Connection'] == 'Upgrade'
+      @method = :WEBSOCKET
+      @is_websocket = true
+    end
+
+    # Deal with EventSource
+    if @header['Accept'] == 'text/event-stream'
+      @method = :EVENTSOURCE
+      @is_eventsource = true
+    end
+
+    @method = @method.to_sym
+    nil
+  end
+
+  # Syntactic sugar for whether a request header is parsed
+  # @return [Boolean] parsed or not
+  def parsed?
+    @parsed
+  end
+
+  # Syntactic sugar for whether a request body is parsed
+  # @return [Boolean] parsed or not
+  def body_parsed?
+    @body_parsed
+  end
+
+  # Syntactic sugar for whether a request is a websocket request
+  # @return [Boolean] websocket or not
+  def websocket?
+    @is_websocket
+  end
+
+  # Syntactic sugar for whether a request is an eventsource request
+  # @return [Boolean] eventsource or not
+  def eventsource?
+    @is_eventsource
+  end
+end

data/lib/midori/response.rb

@@ -0,0 +1,34 @@
+##
+# Class for midori response
+# @attr [String] status HTTP response status
+# @attr [Hash] header HTTP response header
+# @attr [String] body HTTP response body
+class Midori::Response
+  attr_accessor :status, :header, :body
+
+  # @param [Hash] options HTTP response
+  # @option options [Integer] code HTTP response code
+  # @option options [Hash] header HTTP response header
+  # @option options [String] body HTTP response body
+  # Init a Response
+  def initialize(options = {})
+    code = options[:status] || 200
+    @status = Midori::Const::STATUS_CODE[code]
+    @header = options[:header] || Midori::Const::DEFAULT_HEADER.clone
+    @body = options[: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
+end

data/lib/midori/route.rb

@@ -0,0 +1,20 @@
+##
+# Class for Midori route
+# @attr [String] method HTTP method
+# @attr [Regexp] path regex to match
+# @attr [Proc] function what to do after matched
+# @attr [Array<Class>] middlewares middlewares used in the route
+class Midori::Route
+  attr_accessor :method, :path, :function, :middlewares
+
+  # Define a route
+  # @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
+    @function = function
+    @middlewares = []
+  end
+end

data/lib/midori/runner.rb

@@ -0,0 +1,63 @@
+##
+# Abstract runner class to control instance of Midori Server
+# @attr [String] bind the address to bind
+# @attr [Integer] port the port to bind
+# @attr [Logger] logger midori logger
+class Midori::Runner
+  attr_reader :bind, :port, :logger
+
+  # Define status of a runner
+  # @param [Class] api inherited from [Midori::API]
+  # @param [Class] configure inherited from [Midori::Configure]
+  def initialize(api, configure = Midori::Configure)
+    @logger = configure.logger
+    Midori.logger = configure.logger
+    @bind = configure.bind
+    @port = configure.port
+    @api = (api.is_a?Midori::APIEngine) ? api : Midori::APIEngine.new(api, configure.route_type)
+    @before = configure.before
+  end
+
+  # Get Midori server whether running
+  # @return [Boolean] [true] running
+  # @return [Boolean] [false] not running
+  def running?
+    !!@server
+  end
+
+  # Start the Midori server
+  # @note This is an async method, but no callback
+  def start
+    return false if running? || EventLoop.running?
+    @logger.info "Midori #{Midori::VERSION} is now running on #{bind}:#{port}".blue
+    @server = TCPServer.new(@bind, @port)
+    EventLoop.register(@server, :r) do |monitor|
+      socket = monitor.io.accept_nonblock
+      connection = Midori::Connection.new(socket)
+      connection.server_initialize(@api, @logger)
+    end
+    async_fiber(Fiber.new do
+      @before.call
+    end)
+    EventLoop.start
+    nil
+  end
+
+  # Stop the Midori server
+  # @note This is an async method, but no callback
+  # @return [Boolean] [true] stop successfully
+  # @return [Boolean] [false] nothing to stop
+  def stop
+    if running?
+      @logger.info 'Stopping Midori'.blue
+      EventLoop.deregister @server
+      @server.close
+      @server = nil
+      EventLoop.stop
+      true
+    else
+      @logger.error 'Midori Server has NOT been started'.red
+      false
+    end
+  end
+end

data/lib/midori/sandbox.rb

@@ -0,0 +1,46 @@
+##
+# Sandbox for global error capture
+class Midori::Sandbox
+  class << self
+    def class_initialize
+      @handlers = Hash.new
+      @handlers[Midori::Exception::InternalError] = proc {|e| Midori::Response.new(status: 500, body: "#{e.inspect} #{e.backtrace}")}
+      @handlers[Midori::Exception::NotFound] = proc {|_e| Midori::Response.new(status: 404, body: '404 Not Found')}
+    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
+    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
+    def capture(error)
+      if @handlers[error.class].nil?
+        @handlers[Midori::Exception::InternalError].call(error)
+      else
+        @handlers[error.class].call(error) 
+      end
+    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
+    def run(clean_room, function, *args)
+      begin
+        function.to_lambda(clean_room).call(*args)
+      rescue StandardError => e
+        capture(e)
+      end
+    end
+  end
+
+  private_class_method :class_initialize
+  class_initialize
+end