em-midori 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: '081416a49873c3fef7ed675ec2640bc3923284cc'
-  data.tar.gz: f2ab1575e5b6664572a2167f7dbdbced1b94a45a
+  metadata.gz: b72c4ed56a72fbec6c4ad3476c864725ff799cf8
+  data.tar.gz: f18ebee6e089fd9e981519c54ac24daa14a015d0
 SHA512:
-  metadata.gz: 128bb0d384e2eb10978a03532c68db04d8bf668260a211ce6d94a46d5970bea2fa5e9bad94a9797329843a611e657618858d988313764031c5452cbf37b17458
-  data.tar.gz: 441c0ee3debb05818d91417533ef0a42f1ab609b3dd28a7b422ee28a9ce84b1b30208d6d20927fb8c6d6ccc90cc54b0e13bb7f881e260f9ace5f26c71d25d3de
+  metadata.gz: a800b68b2d413aadff9c1fa63569e28adf8194806012d2ce7d016f280ee3f28c228b4a22a44a481aa412551186887f4235f264e74811e1e78f5a47d81386d125
+  data.tar.gz: 1d9d3288d00d8293a18ae4baa99943d25a34adcb0a11c82a97ed3e1e63b0b014762e0a8f359069dcc65399184bbcb70cf4091011885b28eb83cada0b9049ab8a

data/lib/midori.rb

@@ -1,22 +1,17 @@
 require 'digest/sha1'
 require 'stringio'
-require 'nio'
 require 'fiber'
 require 'logger'
 require 'http/parser'
 require 'mustermann'
+require 'murasaki'
 require 'socket'
 
 require_relative 'midori/core_ext/configurable'
 require_relative 'midori/core_ext/string'
-require_relative 'midori/core_ext/event_loop'
-require_relative 'midori/core_ext/timer'
-require_relative 'midori/core_ext/promise'
 require_relative 'midori/core_ext/define_class'
 require_relative 'midori/core_ext/proc'
-require_relative 'midori/core_ext/safe_require'
 
-require_relative 'midori/version'
 require_relative 'midori/const'
 require_relative 'midori/exception'
 require_relative 'midori/env'

data/lib/midori/api.rb

@@ -339,7 +339,7 @@ class Midori::API
     # @param [String, Regexp] path path definition
     # @param [Proc] block process to run when route matched
     # @return [nil] nil
-    def add_route(method, path, block)
+    private def add_route(method, path, block)
       # Argument check
       raise ArgumentError unless path.is_a?String
 
@@ -380,13 +380,11 @@ class Midori::API
       end
     end
 
-    def inherited(subclass)
+    private def inherited(subclass)
       subclass.class_initialize
     end
   end
 
-  private_class_method :add_route, :inherited
-
   # Constants of supported methods in route definition
   METHODS = %w( delete
                 get

data/lib/midori/api_engine.rb

@@ -22,7 +22,7 @@ class Midori::APIEngine
   end
 
   # Merge all routes with a Depth-first search
-  def merge(prefix, root_api, middlewares)
+  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
@@ -48,7 +48,6 @@ class Midori::APIEngine
       params = route.path.params(request.path)
       next unless params # Skip if not matched
       request.params = params
-      route.middlewares.each { |middleware| request = middleware.before(request) }
       clean_room = Midori::CleanRoom.new(request)
       if request.websocket?
         # Send 101 Switching Protocol
@@ -66,10 +65,12 @@ class Midori::APIEngine
         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 unless result.nil?
-        response = (result.is_a?Midori::Response) ? result : clean_room.raw_response
-        route.middlewares.reverse_each { |middleware| response = middleware.after(request, response) }
+        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
@@ -85,5 +86,24 @@ class Midori::APIEngine
     header
   end
 
-  private :merge
+  # 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/core_ext/configurable.rb

@@ -20,13 +20,11 @@ module Configurable
     self
   end
 
-  private
-
   # Dynamically defines a method on settings.
   # @param [String] name method name
   # @param [Proc] content method content
   # @return [nil] nil
-  def define_singleton(name, content = Proc.new)
+  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)

data/lib/midori/version.rb

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

data/tutorial/essentials/installation.md

@@ -6,38 +6,32 @@ Open up a command line prompt. Any commands prefaced with a dollar sign `$` sh
 
 ```
  $ ruby -v
- ruby 2.4.0p0
+ ruby 2.4.1p111
 ```
 
 Generally, midori supports the following ruby interpreters:
 
-- Ruby (MRI) **>= 2.1.0**
-- JRuby >= **9.0.4.0**
+- Ruby (MRI) **>= 2.2.6**
 
  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
+- Ruby (MRI)
+  - 2.2.7
+  - 2.3.4
+  - 2.4.1
 
 **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.**
+- **For JRuby users, due to some C extensions used in midori, it is still unable to run on the current version of JRuby.**
+- **For macOS users, you may meet performance problem due to the issue of [nio4r](https://github.com/socketry/nio4r/issues/125). Very few people would use macOS in production, so this issue may not affect much. We would still be working hard on fixing it, but the issue wouldn't be a high priority one.**
 
-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.
+It's hard to say that if it is possible for running on other ruby implementations like Rubinius or RubyMotion, 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.12
+Successfully installed em-midori-0.3.0
 1 gem installed
 ```
 
@@ -50,7 +44,7 @@ $ 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.12 is now running on 127.0.0.1:8080
+Midori 0.3.0 is now running on 127.0.0.1:8080
 ```
 
 ## Use Bundler
@@ -60,7 +54,7 @@ Example `Gemfile` of basic usage as following:
 ```ruby
 source 'https://rubygems.org'
 gem 'bundler', '~> 1.0'
-gem 'em-midori', '~> 0.1', require: 'midori'
+gem 'em-midori', '~> 0.3', require: 'midori'
 ```
 
 and then running:
@@ -83,7 +77,7 @@ 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'
+gem 'em-midori', '~> 0.3', 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). 

data/tutorial/essentials/request_handling.md

@@ -49,7 +49,7 @@ class ExampleAPI < Midori::API
   end
   
   get '/case_2' do
-    header['Example-Header'] = 'Example-Value'
+    @header['Example-Header'] = 'Example-Value'
     'Hello'
     # HTTP/1.1 200 OK
     # Server: Midori/1.0
@@ -60,11 +60,10 @@ class ExampleAPI < Midori::API
   
   get '/case_3' do
     @status = 202
-    header['Example-Header'] = 'Example-Value'
+    @header['Example-Header'] = 'Example-Value'
     Midori::Response.new(status: 200, header: {}, body: 'Hello') # Overrides everything else
     # HTTP/1.1 200 OK
     # Server: Midori/1.0
-    # Example-Header: Example-Value
     #
     # Hello
   end

data/tutorial/essentials/routing.md

@@ -40,7 +40,7 @@ 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.
+Midori not only supports the methods above, it supports almost 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
 
@@ -111,7 +111,7 @@ class ExampleAPI < Midori::API
 end
 ```
 
-midori also supports `EventSource ` connection as part of your route.
+midori also supports `EventSource` connection as part of your route.
 
 Here's a chatroom example using eventsource in midori:
 

data/tutorial/essentials/runner.md

@@ -0,0 +1,59 @@
+# Runner
+
+## Introdution
+
+`Runner` is the container of midori server. You could create, start, stop midori instance by `Runner`.
+
+`Runner` use `Midori::Configure` as its configuration by default.
+
+## Examples
+
+Here're some examples for common usages
+
+### Port Binding
+
+Start midori instance with port `4567` instead of the default `8080`.
+
+```ruby
+require 'midori'
+class API < Midori::API
+  get '/' do
+    'Hello World'
+  end
+end
+
+Midori::Configure.set :port, 4567
+Midori::Runner.new(API).start
+```
+
+### Address Binding
+
+Start midori instance listening to all IP addresses.
+
+```ruby
+require 'midori'
+class API < Midori::API
+  get '/' do
+    'Hello World'
+  end
+end
+
+Midori::Configure.set :bind, '0.0.0.0'
+Midori::Runner.new(API).start
+```
+
+### Stop Midori
+
+Stop midori instance when specified route been called.
+
+```ruby
+require 'midori'
+$runner = nil
+class API < Midori::API
+  get '/stop' do
+    $runner.stop
+  end
+end
+
+$runner = Midori::Runner.new(API).start
+```

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: em-midori
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - HeckPsi Lab
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-06-08 00:00:00.000000000 Z
+date: 2017-06-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: nio4r
+  name: murasaki
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '0.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '0.1'
 - !ruby/object:Gem::Dependency
   name: mustermann
   requirement: !ruby/object:Gem::Requirement
@@ -71,20 +71,11 @@ files:
 - lib/midori/const.rb
 - lib/midori/core_ext/configurable.rb
 - lib/midori/core_ext/define_class.rb
-- lib/midori/core_ext/event_loop.rb
 - lib/midori/core_ext/proc.rb
-- lib/midori/core_ext/promise.rb
-- lib/midori/core_ext/safe_require.rb
 - lib/midori/core_ext/string.rb
-- lib/midori/core_ext/timer.rb
 - lib/midori/env.rb
 - lib/midori/eventsource.rb
 - lib/midori/exception.rb
-- lib/midori/extension/file.rb
-- lib/midori/extension/net.rb
-- lib/midori/extension/redic.rb
-- lib/midori/extension/sequel/mysql2.rb
-- lib/midori/extension/sequel/postgres.rb
 - lib/midori/logger.rb
 - lib/midori/middleware.rb
 - lib/midori/request.rb

data/lib/midori/core_ext/event_loop.rb

@@ -1,118 +0,0 @@
-##
-# EventLoop Module, providing main loop for events
-module EventLoop
-  class << self
-    # Config EvnetLoop, call by default if any other methods called
-    # @param [NIO::Selector] selector an event selector
-    def config(selector = NIO::Selector.new)
-      # Raw NIO Selector
-      @selector = selector
-      # Array of active timers
-      @timers = []
-      # Hash of io and its callback
-      @ios = Hash.new
-      # IO queue
-      @queue = Hash.new
-    end
-
-    # Add timer in event loop
-    # @param [EventLoop::Timer] timer timer to insert
-    # @return [nil] nil
-    def add_timer(timer)
-      config if @selector.nil?
-      timer.start_time = Time.now.to_f + timer.time
-      @timers << timer
-      nil
-    end
-
-    # Register I/O event with queue protection
-    # @param [IO] io io to register
-    # @param [Symbol] interest :r for read only, :w for write only, and :rw for both
-    # @yield what to run when io callbacks
-    # @return [nil] nil
-    def register(io, interest=(:rw), &callback)
-      config if @selector.nil?
-      if @queue[io.to_i].nil?
-        @queue[io.to_i] = Array.new
-        register_raw(io, interest, callback)
-      else
-        @queue[io.to_i] << [io, interest, callback]
-      end
-      nil
-    end
-
-    # Register I/O event directly, without any queue protection
-    # @param [IO] io io to register
-    # @param [Symbol] interest :r for read only, :w for write only, and :rw for both
-    # @param [Proc] callback what to run when io callbacks
-    # @return [nil] nil
-    def register_raw(io, interest=(:rw), callback)
-      config if @selector.nil?
-      @selector.register(io, interest)
-      @ios[io] = { callback: callback }
-      nil
-    end
-
-    # Deregister I/O event
-    # @param [IO] io io to deregister
-    # @return [nil] nil
-    def deregister(io)
-      fd = io.to_i
-      @selector.deregister(io)
-      @ios.delete(io)
-      next_register = @queue[fd].shift
-      next_register.nil? ? @queue.delete(fd) : register_raw(*next_register)
-      nil
-    end
-
-    # Run I/O selector once
-    # @return [nil] nil
-    def run_once
-      config if @selector.nil?
-      @selector.select(0.2) do |monitor| # Timeout for 0.2 secs
-        @ios[monitor.io][:callback].call(monitor)
-      end
-      timer_once
-      nil
-    end
-
-    # Run timer once
-    # @return [nil] nil
-    def timer_once
-      config if @selector.nil?
-      now_time = Time.now.to_f
-      @timers.delete_if do |timer|
-        if timer.start_time < now_time
-          timer.callback.call
-          true
-        end
-      end
-      nil
-    end
-
-    # Start the event loop
-    # @return [nil] nil
-    def start
-      return if running?
-      @stop = false
-      until @stop
-        run_once
-      end
-      @stop = nil
-    end
-
-    # Set the stop flag
-    # @return [nil] nil
-    def stop
-      @stop = true
-      nil
-    end
-
-    # Detect the stop flag
-    # @return [Boolean] return if eventloop is set to be stopped
-    def running?
-      @stop = true if @stop.nil?
-      !@stop
-    end
-  end
-end

data/lib/midori/core_ext/promise.rb

@@ -1,70 +0,0 @@
-##
-# Meta-programming String for Syntactic Sugars
-# Referenced from {Qiita}[http://qiita.com/south37/items/99a60345b22ef395d424]
-class Promise
-  # Init a Promise
-  # @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
-  # @return [nil] nil
-  def then(&resolve)
-    @callback.call(resolve)
-  end
-end
-
-module Kernel
-  # Make fiber as async chain
-  # @param [Fiber] fiber root of async chain
-  def async_fiber(fiber)
-    chain = proc do |result|
-      next unless result.is_a? Promise
-      result.then do |val|
-        chain.call(fiber.resume(val))
-      end
-    end
-    chain.call(fiber.resume)
-  end
-
-  # Define an async method
-  # @param [Symbol] method method name
-  # @yield async method
-  # @example
-  #   async :hello do 
-  #     puts 'Hello'
-  #   end
-  def async(method)
-    define_singleton_method method do |*args|
-      async_fiber(Fiber.new {yield(*args)})
-    end
-  end
-
-  # 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)
-    result = Fiber.yield promise
-    if result.is_a? PromiseException
-      raise result.payload
-    end
-    result
-  end
-end
-
-
-##
-# Exceptions for Promises
-# @!attribute [r] payload
-#   @return [Exception] raw execption
-class PromiseException < Exception
-  attr_reader :payload
-  # Init PromiseException with existed Exception
-  # @param [Exception] payload raw execption
-  def initialize(payload)
-    @payload = payload
-  end
-end

data/lib/midori/core_ext/safe_require.rb

@@ -1,13 +0,0 @@
-module Kernel
-  # Raise error if Load Failed
-  # @param [String] file file to Load
-  # @param [String] prompt To prompt what when load error
-  # @return [Boolean] whether it has been required already
-  def safe_require(file, prompt)
-    begin
-      require file
-    rescue LoadError => _e
-      raise prompt
-    end
-  end
-end

data/lib/midori/core_ext/timer.rb

@@ -1,22 +0,0 @@
-##
-# Timer Object in EventLoop
-# @!attribute [r] time
-#   @return [Float] timeout length
-# @!attribute [r] callback
-#   @return [Proc] proc to call when callbacks
-# @!attribute start_time
-#   @return [Float] when timer should callbacks
-class EventLoop::Timer
-
-  attr_reader :time, :callback
-  attr_accessor :start_time
-
-  # Init a timer with a time period and callback
-  # @param [Float] time timeout length
-  # @yield proc to call when callbacks
-  def initialize(time, &callback)
-    @time = time
-    @callback = callback
-    @start_time = Float::INFINITY
-  end
-end

data/lib/midori/extension/file.rb

@@ -1,51 +0,0 @@
-##
-# Midori Extension of File reading and writing
-class Midori::File
-  # Init File object
-  # @param [Array] args same args like File.new
-  def initialize(*args)
-    @file = File.new(*args)
-  end
-
-  # read file
-  # @return [String] string readed
-  def read
-    await(Promise.new do |resolve|
-      data = ''
-      EventLoop.register(@file, :r) do
-        if @file.eof?
-          EventLoop.deregister(@file)
-          resolve.call(data)
-        else
-          data << @file.read_nonblock(16384)
-        end
-      end
-    end)
-  end
-
-  # write file
-  # @param [String] data string to be written
-  def write(data)
-    await(Promise.new do |resolve|
-      written = 0
-      EventLoop.register(@file, :w) do
-        written += @file.write_nonblock(data[written..-1])
-        if written == data.size
-          EventLoop.deregister(@file)
-          resolve.call(written)
-        end
-      end
-    end)
-  end
-
-  # raw file object
-  # @return [File] file
-  def raw
-    @file
-  end
-
-  # Close the file
-  def close
-    @file.close
-  end
-end

data/lib/midori/extension/net.rb

@@ -1,42 +0,0 @@
-require 'net/protocol'
-
-##
-# Meta programming Net class for async HTTP and FTP connection
-class Net::BufferedIO
-  # Wait till io finishes
-  # @param [Symbol] interest
-  def wait_io(interest)
-    await(Promise.new do |resolve|
-      io = @io.to_io
-      EventLoop.register(io, interest) do
-        EventLoop.deregister(io)
-        resolve.call(self)
-      end
-    end)
-  end
-
-  # Fill until the operation finishes
-  def rbuf_fill
-    loop do
-      case rv = @io.read_nonblock(BUFSIZE, exception: false)
-        when String
-          return @rbuf << rv
-        when :wait_readable
-          wait_io(:r)
-        # @io.to_io.wait_readable(@read_timeout) or raise Net::ReadTimeout
-        # continue looping
-        when :wait_writable
-          # OpenSSL::Buffering#read_nonblock may fail with IO::WaitWritable.
-          # http://www.openssl.org/support/faq.html#PROG10
-          # :nocov:
-          wait_io(:w)
-        # @io.to_io.wait_writable(@read_timeout) or raise Net::ReadTimeout
-        # continue looping
-        when nil
-          # callers do not care about backtrace, so avoid allocating for it
-          raise EOFError, 'end of file reached', []
-        # :nocov:
-      end
-    end
-  end
-end

data/lib/midori/extension/redic.rb

@@ -1,99 +0,0 @@
-##
-# Meta-programming hiredis for redis async extension
-module Hiredis
-  require 'hiredis/connection'
-  # Overwrite with ruby implementation to hook IO
-  require 'hiredis/ruby/connection'
-  require 'hiredis/ruby/reader'
-  # Redis Connection
-  Connection = Ruby::Connection
-  # Redis Result Reader
-  Reader = Ruby::Reader
-
-  ##
-  # Meta-programming hiredis for redis async extension
-  module Ruby
-    ##
-    # Meta-programming hiredis for redis async extension
-    class Connection
-      # Do redis query
-      # @param [Array] args equal to Hiredis write args
-      def query(args)
-        await(Promise.new do |resolve|
-          read_flag = false
-          data = pre_write(args)
-          written = 0
-          EventLoop.register(@sock, :rw) do |monitor|
-            if read_flag && monitor.readable?
-              # Reading
-              _read(resolve, @sock)
-            end
-            if !read_flag && monitor.writable?
-              # Writing
-              written += @sock.write_nonblock(data[written..-1])
-              read_flag = true if written == string_size(data)
-            end
-          end
-        end)
-      end
-
-      private
-        def pre_write(args)
-          command = []
-          command << "*#{args.size}"
-          args.each do |arg|
-            arg = arg.to_s
-            command << "$#{string_size arg}"
-            command << arg
-          end
-          data = command.join(COMMAND_DELIMITER) + COMMAND_DELIMITER
-          data.force_encoding('binary') if data.respond_to?(:force_encoding)
-          data
-        end
-
-        def _read(resolve, sock)
-          @reader.feed @sock.read_nonblock(1024)
-          reply = @reader.gets
-          if reply
-            EventLoop.deregister(sock)
-            resolve.call(reply)
-          end
-        end
-    end
-  end
-end
-
-require 'redic'
-
-##
-# Meta-programming Redic for redis async extension
-class Redic
-  # Meta-programming Redic for redis async extension
-  class Client
-    # Connect redis, yield optional
-    def connect
-      establish_connection unless connected?
-      if block_given?
-        # Redic default yield
-        # :nocov:
-        @semaphore.synchronize do
-          yield
-        end
-        # :nocov:
-      end
-    end
-    
-    # Call without thread lock
-    # @param [Array] args same params as Redic
-    def call(*args)
-      @connection.query(*args)
-    end
-  end
-
-  # Call without thread lock
-  # @param [Array] args same params as Redic
-  def call(*args)
-    @client.connect
-    @client.call(args)
-  end
-end

data/lib/midori/extension/sequel/mysql2.rb

@@ -1,111 +0,0 @@
-safe_require 'sequel', 'gem install sequel'
-require 'sequel/adapters/mysql2'
-
-# Management of MySQL Sockets
-MYSQL_SOCKETS = {}
-
-##
-# Meta-programming Sequel for async extensions
-module Sequel
-  # Midori Extension of sequel MySQL through meta programming
-  module Mysql2
-    # Midori Extension of sequel MySQL through meta programming
-    class Database
-      # Execute the given SQL on the given connection.  If the :type
-      # option is :select, yield the result of the query, otherwise
-      # yield the connection if a block is given.
-      # @param [Mysql2::Client] conn connection to database
-      # @param [String] sql sql query
-      # @param [Hash] opts optional options
-      # @return [Mysql2::Result] MySQL results
-      def _execute(conn, sql, opts) # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
-        begin
-          # :nocov:
-          stream = opts[:stream]
-          if NativePreparedStatements
-            if (args = opts[:arguments])
-              args = args.map{|arg| bound_variable_value(arg)}
-            end
-
-            case sql
-              when ::Mysql2::Statement
-                stmt = sql
-              when Dataset
-                sql = sql.sql
-                close_stmt = true
-                stmt = conn.prepare(sql)
-            end
-          end
-
-          r = log_connection_yield((log_sql = opts[:log_sql]) ? sql + log_sql : sql, conn, args) do
-            if stmt
-              conn.query_options.merge!(cache_rows: true,
-                                        database_timezone: timezone,
-                                        application_timezone: Sequel.application_timezone,
-                                        stream: stream,
-                                        cast_booleans: convert_tinyint_to_bool)
-              stmt.execute(*args)
-              # :nocov:
-            else
-              if MYSQL_SOCKETS[conn.socket].nil?
-                MYSQL_SOCKETS[conn.socket] = IO::open(conn.socket)
-              end
-              socket = MYSQL_SOCKETS[conn.socket]
-              await(Promise.new do |resolve|
-                count = 0
-                EventLoop.register(socket, :rw) do
-                  if (count == 0)
-                    # Writable
-                    count += 1
-                    conn.query(sql,
-                              database_timezone: timezone,
-                              application_timezone: Sequel.application_timezone,
-                              stream: stream,
-                              async: true)
-                  else
-                    # Readable
-                    begin
-                      EventLoop.deregister(socket)
-                      resolve.call(conn.async_result)
-                    rescue ::Mysql2::Error => e
-                      resolve.call(PromiseException.new(e))
-                      next
-                    end
-                  end
-                end
-              end)
-            end
-          end
-
-          # :nocov:
-          if opts[:type] == :select
-            if r
-              if stream
-                begin
-                  r2 = yield r
-                ensure
-                  # If r2 is nil, it means the block did not exit normally,
-                  # so the rest of the results must be drained to prevent
-                  # "commands out of sync" errors.
-                  r.each{} unless r2
-                end
-              else
-                yield r
-              end
-            end
-          elsif block_given?
-            yield conn
-          end
-        rescue ::Mysql2::Error => e
-          raise_error(e)
-        ensure
-          if stmt
-            conn.query_options.replace(conn.instance_variable_get(:@sequel_default_query_options))
-            stmt.close if close_stmt
-          end
-          # :nocov:
-        end
-      end
-    end
-  end
-end

data/lib/midori/extension/sequel/postgres.rb

@@ -1,45 +0,0 @@
-safe_require 'sequel', 'gem install sequel'
-require 'sequel/adapters/postgres'
-
-# Management of Postgres Sockets
-POSTGRES_SOCKETS = {}
-
-##
-# 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
-  def execute_query(sql, args)
-    @db.log_connection_yield(sql, self, args) do
-      if POSTGRES_SOCKETS[self].nil?
-        POSTGRES_SOCKETS[self] = IO::open(socket)
-      end
-      socket_object = POSTGRES_SOCKETS[self]
-      await(Promise.new do |resolve|
-        count = 0
-        EventLoop.register(socket_object, :rw) do
-          begin
-            if (count == 0)
-              # Writable
-              unless is_busy
-                send_query(sql)
-                count += 1
-              end
-            else
-              # Readable
-              EventLoop.deregister(socket_object)
-              resolve.call(get_result)
-            end
-          # For extra errors
-          # :nocov:
-          rescue => e
-            resolve.call(PromiseException.new(e))
-          # :nocov:
-          end
-        end
-      end)
-    end
-  end
-end