qeweney 0.2 → 0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 468a536796430b202206a5b2e6fe1e05cdc2b9ff248735ceab4fa7ca458b812e
-  data.tar.gz: 379a9bdb10b73d2a5fbce967ec10149fd0c36ce58819fe27da847a3e1194ae27
+  metadata.gz: 57bbb94d61917bad178ee53693fdecc3f3aa878495c3d53d04d263bd34934792
+  data.tar.gz: 5075929ee6a35dc1c1420b6a312ff5c861e6e2b7267993eacb3b55ec09d6f6c6
 SHA512:
-  metadata.gz: 17e66c2fbcf0b60c7cf8023ff7c0cda04e3ec3c527da5019838bf66ed454e10c4fada6b45e6ad56de479812a2e215e692fd566dc3167457e92ed8e88fc54de39
-  data.tar.gz: d46cabcc28e1da7ba15f4603eff436a47198e1c8008e97a3d4c6fb6e7166fddb08f7bea13c537e521784b06c898c9f97d8c9af15677f31516f37a649740ce693
+  metadata.gz: '096b6148118776622ba648d9bb4dc8808575b35beecc90b2893518d83edc402a0d257a79db04d698a656f937249d130b56e0e0eeff4df7475b413a98d9012374'
+  data.tar.gz: 6b9fe12bd28d762e1116313bf9dfb6f4e4804d75dd02edbf887449bb24100e098e178121401b4061f892d47c1dfee1dc5adc8b4f22376a6c8b08c96f4b3a0302

data/CHANGELOG.md

@@ -1,3 +1,26 @@
+## 0.7 20921-03-04
+
+- Add `#route_relative_path` method
+
+## 0.6 2021-03-03
+
+- More work on routing (still WIP)
+- Implement two-way Rack adapters
+
+## 0.5 2021-02-15
+
+- Implement upgrade and WebSocket upgrade responses
+
+## 0.4 2021-02-12
+
+- Implement caching and compression for serving static files
+
+## 0.3 2021-02-12
+
+- Implement `Request#serve_io`, `Request#serve_file`, `Request#redirect`
+- Add basic MIME types
+- Add HTTP status codes
+
 ## 0.2 2021-02-11
 
 - Gem renamed to Qeweney

data/Gemfile.lock

@@ -1,13 +1,14 @@
 PATH
   remote: .
   specs:
-    qeweney (0.2)
+    qeweney (0.7)
       escape_utils (~> 1.2.1)
 
 GEM
   remote: https://rubygems.org/
   specs:
     ansi (1.5.0)
+    benchmark-ips (2.8.4)
     builder (3.2.4)
     escape_utils (1.2.1)
     minitest (5.11.3)
@@ -23,6 +24,7 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
+  benchmark-ips (~> 2.8.3)
   minitest (~> 5.11.3)
   minitest-reporters (~> 1.4.2)
   qeweney!

data/README.md

@@ -1,8 +1,8 @@
-# QNA
+# Qeweney
 
 ## Cross-library feature rich HTTP request / response API
 
-QNA provides a uniform API for dealing with HTTP requests and responses.
+Qeweney provides a uniform API for dealing with HTTP requests and responses.
 
 ## Features
 

data/TODO.md

@@ -0,0 +1,81 @@
+## Serve files / arbitrary content
+
+- `#serve_file(path, opts)`
+  - See here: https://golang.org/pkg/net/http/#ServeFile
+  - support for `Range` header
+
+- `#serve_content(io, opts)`
+  - See here: https://golang.org/pkg/net/http/#ServeContent
+  - support for `Range` header
+
+## route on host
+
+- `#on_host`:
+
+  ```ruby
+  req.route do
+    req.on_host 'example.com' do
+      req.redirect "https://www.example.com#{req.uri}"
+    end
+  end
+  ```
+
+- `#on_http`:
+
+  ```ruby
+  req.route do
+    req.on_http do
+      req.redirect "https://#{req.host}#{req.uri}"
+    end
+  end
+  ```
+
+- shorthand:
+
+  ```ruby
+  req.route do
+    req.on_http { req.redirect_to_https }
+    req.on_host 'example.com' do
+      req.redirect_to_host('www.example.com')
+    end
+  end
+  ```
+
+## templates
+
+- needs to be pluggable - allow any kind of template
+
+```ruby
+WEBSITE_PATH = File.join(__dir__, 'docs')
+STATIC_PATH = File.join(WEBSITE_PATH, 'static')
+LAYOUTS_PATH = File.join(WEBSITE_PATH, '_layouts')
+
+PAGES = Tipi::PageManager(
+  base_path: WEBSITE_PATH,
+  engine: :markdown,
+  layouts: LAYOUTS_PATH
+)
+
+app = Tipi.app do |r|
+  r.on 'static' do
+    r.serve_file(r.route_path, base_path: ASSETS_PATH)
+  end
+
+  r.default do
+    PAGES.serve(r)
+  end
+end
+```
+
+## Rewriting URLs
+
+```ruby
+app = Tipi.app do |r|
+  r.rewrite '/' => '/docs/index.html'
+  r.rewrite '/docs' => '/docs/'
+  r.rewrite '/docs/' => '/docs/index.html'
+
+  # or maybe
+  r.on '/docs/'
+end
+```

data/examples/routing_benchmark.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'qeweney'
+require 'benchmark/ips'
+
+module Qeweney
+  class MockAdapter
+    attr_reader :calls
+
+    def initialize
+      @calls = []
+    end
+
+    def method_missing(sym, *args)
+      calls << [sym, *args]
+    end
+  end
+
+  def self.mock(headers = {})
+    Request.new(headers, MockAdapter.new)
+  end
+
+  class Request
+    def response_calls
+      adapter.calls
+    end
+  end
+end
+
+def create_mock_request
+  Qeweney.mock(':path' => '/hello/world', ':method' => 'post')
+end
+
+CTApp = ->(r) do
+  r.route do
+    r.on_root { r.redirect '/hello' }
+    r.on('hello') do
+      r.on_get('world') { r.respond 'Hello world' }
+      r.on_get { r.respond 'Hello' }
+      r.on_post do
+        # puts 'Someone said Hello'
+        r.redirect '/'
+      end
+    end
+  end
+end
+
+FlowControlApp = ->(r) do
+  if r.path == '/'
+    return r.redirect '/hello'
+  elsif r.current_path_part == 'hello'
+    r.enter_route
+    if r.method == 'get' && r.current_path_part == 'world'
+      return r.respond('Hello world')
+    elsif r.method == 'get'
+      return r.respond('Hello')
+    elsif r.method == 'post'
+      return r.redirect('/')
+    end
+    r.leave_route
+  end
+  r.respond(nil, ':status' => 404)
+end
+
+class Qeweney::Request
+  def get?
+    method == 'get'
+  end
+
+  def post?
+    method == 'post'
+  end
+end
+
+NicerFlowControlApp = ->(r) do
+  case r.current_path_part
+  when '/'
+    return r.redirect('/hello')
+  when 'hello'
+    r.enter_route
+    if r.get? && r.current_route == 'world'
+      return r.respond('Hello world')
+    elsif r.get?
+      return r.respond('Hello')
+    elsif r.post?
+      return r.redirect('/')
+    end
+    r.leave_route
+  end
+  r.respond(nil, ':status' => 404)
+end
+
+OptimizedRubyApp = ->(r) do
+  path = r.path
+  if path == '/'
+    return r.redirect('/hello')
+  elsif path =~ /^\/hello(.+)/
+    method = r.method
+    if method == 'get'
+      rest = Regexp.last_match(1)
+      if rest == '/world'
+        return r.respond('Hello world')
+      else
+        return r.respond('Hello')
+      end
+    elsif method == 'post' 
+      # puts 'Someone said Hello'
+      return r.redirect('/')
+    end
+  end
+  r.respond(nil, ':status' => 404)
+end
+
+def test
+  r = create_mock_request
+  puts '* catch/throw'
+  CTApp.call(r)
+  p r.response_calls
+
+  r = create_mock_request
+  puts '* classic flow control'
+  FlowControlApp.call(r)
+  p r.response_calls
+
+  r = create_mock_request
+  puts '* nicer flow control'
+  NicerFlowControlApp.call(r)
+  p r.response_calls
+
+  r = create_mock_request
+  puts '* optimized Ruby'
+  OptimizedRubyApp.call(r)
+  p r.response_calls
+end
+
+def benchmark
+  Benchmark.ips do |x|
+    x.config(:time => 3, :warmup => 1)
+
+    x.report("catch/throw") { CTApp.call(create_mock_request) }
+    x.report("flow control") { FlowControlApp.call(create_mock_request) }
+    x.report("nicer flow control") { NicerFlowControlApp.call(create_mock_request) }
+    x.report("hand-optimized") { OptimizedRubyApp.call(create_mock_request) }
+
+    x.compare!
+  end
+end
+
+test
+benchmark

data/lib/qeweney.rb

@@ -4,3 +4,5 @@ module Qeweney
 end
 
 require_relative 'qeweney/request.rb'
+require_relative 'qeweney/status.rb'
+

data/lib/qeweney/mime_types.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Qeweney
+  # File extension to MIME type mapping
+  module MimeTypes
+    TYPES = {
+      'html'  => 'text/html',
+      'css'   => 'text/css',
+      'js'    => 'application/javascript',
+      'txt'   => 'text/plain'
+
+      'gif'   => 'image/gif',
+      'jpg'   => 'image/jpeg',
+      'jpeg'  => 'image/jpeg',
+      'png'   => 'image/png',
+      'ico'   => 'image/x-icon',
+
+      'pdf'   => 'application/pdf',
+      'json'  => 'application/json',
+    }.freeze
+
+    def [](ref)
+      case ref
+      when Symbol
+        TYPES[ref.to_s]
+      when /\.?([^\.]+)$/
+        TYPES[Regexp.last_match(1)]
+      else
+        raise "Invalid argument #{ref.inspect}"
+      end
+    end
+  end
+end

data/lib/qeweney/rack.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Qeweney
+  class RackRequestAdapter
+    def initialize(env)
+      @env = env
+      @response_headers = {}
+      @response_body = []
+    end
+
+    def request_headers
+      request_http_headers.merge(
+        ':scheme' => @env['rack.url_scheme'],
+        ':method' => @env['REQUEST_METHOD'].downcase,
+        ':path' => request_path_from_env
+      )
+    end
+
+    def request_path_from_env
+      path = File.join(@env['SCRIPT_NAME'], @env['PATH_INFO'])
+      path = path + "?#{@env['QUERY_STRING']}" if @env['QUERY_STRING']
+      path
+    end
+
+    def request_http_headers
+      headers = {}
+      @env.each do |k, v|
+        next unless k =~ /^HTTP_(.+)$/
+
+        headers[Regexp.last_match(1).downcase.gsub('_', '-')] = v
+      end
+      headers
+    end
+
+    def respond(body, headers)
+      @response_body << body
+      @response_headers = headers
+    end
+
+    def send_headers(headers, empty_response: nil)
+      @response_headers = headers
+    end
+
+    def send_chunk(body, done: false)
+      @response_body << body
+    end
+
+    def finish
+    end
+
+    def rack_response
+      @status = @response_headers.delete(':status')
+      [
+        @status,
+        @response_headers,
+        @response_body
+      ]
+    end
+  end
+
+  def self.rack(&block)
+    proc do |env|
+      adapter = RackRequestAdapter.new(env)
+      req = Request.new(adapter.request_headers, adapter)
+      block.(req)
+      adapter.rack_response
+    end
+  end
+
+  def self.rack_env_from_request(request)
+    Hash.new do |h, k|
+      h[k] = env_value_from_request(request, k)
+    end
+  end
+
+  RACK_ENV = {
+    'SCRIPT_NAME'                    => '',
+    'rack.version'                   => [1, 3],
+    'SERVER_PORT'                    => '80', # ?
+    'rack.url_scheme'                => 'http', # ?
+    'rack.errors'                    => STDERR, # ?
+    'rack.multithread'               => false,
+    'rack.run_once'                  => false,
+    'rack.hijack?'                   => false,
+    'rack.hijack'                    => nil,
+    'rack.hijack_io'                 => nil,
+    'rack.session'                   => nil,
+    'rack.logger'                    => nil,
+    'rack.multipart.buffer_size'     => nil,
+    'rack.multipar.tempfile_factory' => nil
+  }
+  
+  def self.env_value_from_request(request, key)
+    case key
+    when 'REQUEST_METHOD' then request.method
+    when 'PATH_INFO'      then request.path
+    when 'QUERY_STRING'   then request.query_string || ''
+    when 'SERVER_NAME'    then request.headers['host']
+    when 'rack.input'     then InputStream.new(request)
+    when HTTP_HEADER_RE   then request.headers[$1.gsub('_', '-').downcase]
+    else                       RACK_ENV[key]
+    end
+  end
+end

data/lib/qeweney/request.rb

@@ -3,6 +3,7 @@
 require_relative './request_info'
 require_relative './routing'
 require_relative './response'
+require_relative './rack'
 
 module Qeweney
   # HTTP request

data/lib/qeweney/request_info.rb

@@ -17,6 +17,10 @@ module Qeweney
       connection == 'upgrade' && @headers['upgrade']&.downcase
     end
 
+    def websocket_version
+      headers['sec-websocket-version'].to_i
+    end
+
     def protocol
       @protocol ||= @adapter.protocol
     end
@@ -61,6 +65,15 @@ module Qeweney
     def forwarded_for
       @headers['x-forwarded-for']
     end
+
+    # TODO: should return encodings in client's order of preference (and take
+    # into account q weights)
+    def accept_encoding
+      encoding = @headers['accept-encoding']
+      return [] unless encoding
+
+      encoding.split(',').map { |i| i.strip }
+    end
   end
 
   module RequestInfoClassMethods

data/lib/qeweney/response.rb

@@ -1,9 +1,155 @@
 # frozen_string_literal: true
 
+require 'time'
+require 'zlib'
+require 'stringio'
+require 'digest/sha1'
+
+require_relative 'status'
+
 module Qeweney
+  module StaticFileCaching
+    class << self
+      def file_stat_to_etag(stat)
+        "#{stat.mtime.to_i.to_s(36)}#{stat.size.to_s(36)}"
+      end
+      
+      def file_stat_to_last_modified(stat)
+        stat.mtime.httpdate
+      end
+    end
+  end
+
   module ResponseMethods
-    def redirect(url)
-      respond(nil, ':status' => 302, 'Location' => url)
+    def upgrade(protocol, custom_headers = nil)
+      upgrade_headers = {
+        ':status' => Status::SWITCHING_PROTOCOLS,
+        'Upgrade' => protocol,
+        'Connection' => 'upgrade'
+      }
+      upgrade_headers.merge!(custom_headers) if custom_headers
+
+      respond(nil, upgrade_headers)
+    end
+
+    WEBSOCKET_GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
+
+    def upgrade_to_websocket(custom_headers = nil)
+      key = "#{headers['sec-websocket-key']}#{WEBSOCKET_GUID}"
+      upgrade_headers = {
+        'Sec-WebSocket-Accept' => Digest::SHA1.base64digest(key)
+      }
+      upgrade_headers.merge!(custom_headers) if custom_headers
+      upgrade('websocket', upgrade_headers)
+
+      adapter.websocket_connection(self)
+    end
+
+    def redirect(url, status = Status::FOUND)
+      respond(nil, ':status' => status, 'Location' => url)
+    end
+
+    def redirect_to_https(status = Status::MOVED_PERMANENTLY)
+      secure_uri = "https://#{host}#{uri}"
+      redirect(secure_uri, status)
+    end
+
+    def redirect_to_host(new_host, status = Status::FOUND)
+      secure_uri = "//#{new_host}#{uri}"
+      redirect(secure_uri, status)
+    end
+
+    def serve_file(path, opts)
+      full_path = file_full_path(path, opts)
+      stat = File.stat(full_path)
+      etag = StaticFileCaching.file_stat_to_etag(stat)
+      last_modified = StaticFileCaching.file_stat_to_last_modified(stat)
+
+      if validate_static_file_cache(etag, last_modified)
+        return respond(nil, {
+          ':status' => Status::NOT_MODIFIED,
+          'etag' => etag
+        })
+      end
+
+      respond_with_static_file(full_path, etag, last_modified, opts)
+    rescue Errno::ENOENT => e
+      respond(nil, ':status' => Status::NOT_FOUND)
+    end
+
+    def respond_with_static_file(path, etag, last_modified, opts)
+      File.open(path, 'r') do |f|
+        opts = opts.merge(headers: {
+          'etag' => etag,
+          'last-modified' => last_modified,
+        })
+
+        # accept_encoding should return encodings in client's order of preference
+        accept_encoding.each do |encoding|
+          case encoding
+          when 'deflate'
+            return serve_io_deflate(f, opts)
+          when 'gzip'
+            return serve_io_gzip(f, opts)
+          end
+        end
+        serve_io(f, opts)
+      end
+    end
+
+    def validate_static_file_cache(etag, last_modified)
+      if (none_match = headers['if-none-match'])
+        return true if none_match == etag
+      end
+      if (modified_since = headers['if-modified-since'])
+        return true if modified_since == last_modified
+      end
+    
+      false
+    end
+
+    def file_full_path(path, opts)
+      if (base_path = opts[:base_path])
+        File.join(opts[:base_path], path)
+      else
+        path
+      end
+    end
+
+    def serve_io(io, opts)
+      respond(io.read, opts[:headers] || {})
+    end
+
+    def serve_io_deflate(io, opts)
+      deflate = Zlib::Deflate.new
+      headers = opts[:headers].merge(
+        'content-encoding' => 'deflate',
+        'vary' => 'Accept-Encoding'
+      )
+
+      respond(deflate.deflate(io.read, Zlib::FINISH), headers)
+    end
+
+    def serve_io_gzip(io, opts)
+      buf = StringIO.new
+      z = Zlib::GzipWriter.new(buf)
+      z << io.read
+      z.flush
+      z.close
+      headers = opts[:headers].merge(
+        'content-encoding' => 'gzip',
+        'vary' => 'Accept-Encoding'
+      )
+      respond(buf.string, headers)
+    end
+
+    def serve_rack(app)
+      response = app.(Qeweney.rack_env_from_request(self))
+      headers = (response[1] || {}).merge(':status' => response[0])
+      respond(response[2].join, headers)
+
+      # TODO: send separate chunks for multi-part body
+      # TODO: add support for streaming body
     end
   end
 end

data/lib/qeweney/routing.rb

@@ -1,8 +1,13 @@
 # frozen_string_literal: true
 
 module Qeweney
+  def self.route(&block)
+    ->(r) { r.route(&block) }
+  end
+
   module RoutingMethods
     def route(&block)
+      (@path_parts ||= path.split('/'))[@path_parts_idx ||= 1]
       res = catch(:stop) { yield self }
       return if res == :found
   
@@ -11,36 +16,57 @@ module Qeweney
 
     def route_found(&block)
       catch(:stop, &block)
-      throw :stop, :found
+      throw :stop, headers_sent? ? :found : nil
     end
 
     @@regexp_cache = {}
 
-    def routing_path
-      @__routing_path__
+    def route_part
+      @path_parts[@path_parts_idx]
     end
-  
-    def on(route = nil, &block)
-      @__routing_path__ ||= path
 
-      if route
-        regexp = (@@regexp_cache[route] ||= /^\/#{route}(\/.*)?/)
-        return unless @__routing_path__ =~ regexp
+    def route_relative_path
+      @path_parts[@path_parts_idx..-1].join('/')
+    end
+
+    def enter_route
+      @path_parts_idx += 1
+    end
+
+    def leave_route
+      @path_parts_idx -= 1
+    end
 
-        @__routing_path__ = Regexp.last_match(1) || '/'
+    def on(route = nil, &block)
+      if route
+        return unless @path_parts[@path_parts_idx] == route
       end
   
+      enter_route
       route_found(&block)
+      leave_route
     end
 
     def is(route = '/', &block)
-      return unless @__routing_path__ == route
+      return unless @path_parts[@path_parts_idx] == route && @path_parts_idx >= @path_parts.size
 
       route_found(&block)
     end
 
     def on_root(&block)
-      return unless @__routing_path__ == '/'
+      return unless @path_parts_idx > @path_parts.size - 1
+
+      route_found(&block)
+    end
+
+    def on_host(route, &block)
+      return unless host == route
+
+      route_found(&block)
+    end
+
+    def on_plain_http(route, &block)
+      return unless scheme == 'http'
 
       route_found(&block)
     end
@@ -86,8 +112,22 @@ module Qeweney
       route_found(&block)
     end
 
+    def on_upgrade(protocol, &block)
+      return unless upgrade_protocol == protocol
+
+      route_found(&block)
+    end
+
+    def on_websocket_upgrade(&block)
+      on_upgrade('websocket', &block)
+    end
+
     def stop_routing
-      yield if block_given?
+      throw :stop, :found
+    end
+
+    def default
+      yield
       throw :stop, :found
     end
   end

data/lib/qeweney/status.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Qeweney
+  # HTTP status codes
+  module Status
+    # translated from https://golang.org/pkg/net/http/#pkg-constants
+    # https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
+    
+    CONTINUE                        = 100 # RFC 7231, 6.2.1
+    SWITCHING_PROTOCOLS             = 101 # RFC 7231, 6.2.2
+    PROCESSING                      = 102 # RFC 2518, 10.1
+    EARLY_HINTS                     = 103 # RFC 8297
+
+    OK                              = 200 # RFC 7231, 6.3.1
+    CREATED                         = 201 # RFC 7231, 6.3.2
+    ACCEPTED                        = 202 # RFC 7231, 6.3.3
+    NON_AUTHORITATIVE_INFO          = 203 # RFC 7231, 6.3.4
+    NO_CONTENT                      = 204 # RFC 7231, 6.3.5
+    RESET_CONTENT                   = 205 # RFC 7231, 6.3.6
+    PARTIAL_CONTENT                 = 206 # RFC 7233, 4.1
+    MULTI_STATUS                    = 207 # RFC 4918, 11.1
+    ALREADY_REPORTED                = 208 # RFC 5842, 7.1
+    IM_USED                         = 226 # RFC 3229, 10.4.1
+
+    MULTIPLE_CHOICES                = 300 # RFC 7231, 6.4.1
+    MOVED_PERMANENTLY               = 301 # RFC 7231, 6.4.2
+    FOUND                           = 302 # RFC 7231, 6.4.3
+    SEE_OTHER                       = 303 # RFC 7231, 6.4.4
+    NOT_MODIFIED                    = 304 # RFC 7232, 4.1
+    USE_PROXY                       = 305 # RFC 7231, 6.4.5
+
+    TEMPORARY_REDIRECT              = 307 # RFC 7231, 6.4.7
+    PERMANENT_REDIRECT              = 308 # RFC 7538, 3
+
+    BAD_REQUEST                     = 400 # RFC 7231, 6.5.1
+    UNAUTHORIZED                    = 401 # RFC 7235, 3.1
+    PAYMENT_REQUIRED                = 402 # RFC 7231, 6.5.2
+    FORBIDDEN                       = 403 # RFC 7231, 6.5.3
+    NOT_FOUND                       = 404 # RFC 7231, 6.5.4
+    METHOD_NOT_ALLOWED              = 405 # RFC 7231, 6.5.5
+    NOT_ACCEPTABLE                  = 406 # RFC 7231, 6.5.6
+    PROXY_AUTH_REQUIRED             = 407 # RFC 7235, 3.2
+    REQUEST_TIMEOUT                 = 408 # RFC 7231, 6.5.7
+    CONFLICT                        = 409 # RFC 7231, 6.5.8
+    GONE                            = 410 # RFC 7231, 6.5.9
+    LENGTH_REQUIRED                 = 411 # RFC 7231, 6.5.10
+    PRECONDITION_FAILED             = 412 # RFC 7232, 4.2
+    REQUEST_ENTITY_TOO_LARGE        = 413 # RFC 7231, 6.5.11
+    REQUEST_URI_TOO_LONG            = 414 # RFC 7231, 6.5.12
+    UNSUPPORTED_MEDIA_TYPE          = 415 # RFC 7231, 6.5.13
+    REQUESTED_RANGE_NOT_SATISFIABLE = 416 # RFC 7233, 4.4
+    EXPECTATION_FAILED              = 417 # RFC 7231, 6.5.14
+    TEAPOT                          = 418 # RFC 7168, 2.3.3
+    MISDIRECTED_REQUEST             = 421 # RFC 7540, 9.1.2
+    UNPROCESSABLE_ENTITY            = 422 # RFC 4918, 11.2
+    LOCKED                          = 423 # RFC 4918, 11.3
+    FAILED_DEPENDENCY               = 424 # RFC 4918, 11.4
+    TOO_EARLY                       = 425 # RFC 8470, 5.2.
+    UPGRADE_REQUIRED                = 426 # RFC 7231, 6.5.15
+    PRECONDITION_REQUIRED           = 428 # RFC 6585, 3
+    TOO_MANY_REQUESTS               = 429 # RFC 6585, 4
+    REQUEST_HEADER_FIELDS_TOO_LARGE = 431 # RFC 6585, 5
+    UNAVAILABLE_FOR_LEGAL_REASONS   = 451 # RFC 7725, 3
+
+    INTERNAL_SERVER_ERROR           = 500 # RFC 7231, 6.6.1
+    NOT_IMPLEMENTED                 = 501 # RFC 7231, 6.6.2
+    BAD_GATEWAY                     = 502 # RFC 7231, 6.6.3
+    SERVICE_UNAVAILABLE             = 503 # RFC 7231, 6.6.4
+    GATEWAY_TIMEOUT                 = 504 # RFC 7231, 6.6.5
+    HTTP_VERSION_NOT_SUPPORTED      = 505 # RFC 7231, 6.6.6
+    VARIANT_ALSO_NEGOTIATES         = 506 # RFC 2295, 8.1
+    INSUFFICIENT_STORAGE            = 507 # RFC 4918, 11.5
+    LOOP_DETECTED                   = 508 # RFC 5842, 7.2
+    NOT_EXTENDED                    = 510 # RFC 2774, 7
+    NETWORK_AUTHENTICATION_REQUIRED = 511 # RFC 6585, 6
+  end
+end

data/lib/qeweney/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Qeweney
-  VERSION = '0.2'
+  VERSION = '0.7'
 end

data/qeweney.gemspec

@@ -22,4 +22,5 @@ Gem::Specification.new do |s|
   s.add_development_dependency  'rake',               '~>12.3.3'
   s.add_development_dependency  'minitest',           '~>5.11.3'
   s.add_development_dependency  'minitest-reporters', '~>1.4.2'
+  s.add_development_dependency  'benchmark-ips',      '~>2.8.3'
 end

data/test/helper.rb

@@ -11,8 +11,28 @@ require 'minitest/autorun'
 require 'minitest/reporters'
 
 module Qeweney
-  def self.mock(headers)
-    Request.new(headers, nil)
+  class MockAdapter
+    attr_reader :calls
+
+    def initialize
+      @calls = []
+    end
+
+    def method_missing(sym, *args)
+      calls << [sym, *args]
+    end
+  end
+
+  def self.mock(headers = {})
+    headers[':method'] ||= ''
+    headers[':path'] ||= ''
+    Request.new(headers, MockAdapter.new)
+  end
+
+  class Request
+    def response_calls
+      adapter.calls
+    end
   end
 end
 

data/test/test_response.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class RedirectTest < MiniTest::Test
+  def test_redirect
+    r = Qeweney.mock
+    r.redirect('/foo')
+
+    assert_equal [
+      [:respond, nil, {":status"=>302, "Location"=>"/foo"}]
+    ], r.response_calls
+  end
+
+  def test_redirect_wirth_status
+    r = Qeweney.mock
+    r.redirect('/bar', Qeweney::Status::MOVED_PERMANENTLY)
+
+    assert_equal [
+      [:respond, nil, {":status"=>301, "Location"=>"/bar"}]
+    ], r.response_calls
+  end
+end
+
+class StaticFileResponeTest < MiniTest::Test
+  def setup
+    @path = File.join(__dir__, 'helper.rb')
+    @stat = File.stat(@path)
+
+    @etag = Qeweney::StaticFileCaching.file_stat_to_etag(@stat)
+    @last_modified = Qeweney::StaticFileCaching.file_stat_to_last_modified(@stat)
+    @content = IO.read(@path)
+  end
+
+  def test_serve_file
+    r = Qeweney.mock
+    r.serve_file('helper.rb', base_path: __dir__)
+
+    assert_equal [
+      [:respond, @content, { 'etag' => @etag, 'last-modified' => @last_modified }]
+    ], r.response_calls
+  end
+
+  def test_serve_file_with_cache_headers
+    r = Qeweney.mock('if-none-match' => @etag)
+    r.serve_file('helper.rb', base_path: __dir__)
+    assert_equal [
+      [:respond, nil, { 'etag' => @etag, ':status' => Qeweney::Status::NOT_MODIFIED }]
+    ], r.response_calls
+
+    r = Qeweney.mock('if-modified-since' => @last_modified)
+    r.serve_file('helper.rb', base_path: __dir__)
+    assert_equal [
+      [:respond, nil, { 'etag' => @etag, ':status' => Qeweney::Status::NOT_MODIFIED }]
+    ], r.response_calls
+
+    r = Qeweney.mock('if-none-match' => 'foobar')
+    r.serve_file('helper.rb', base_path: __dir__)
+    assert_equal [
+      [:respond, @content, { 'etag' => @etag, 'last-modified' => @last_modified }]
+    ], r.response_calls
+
+    r = Qeweney.mock('if-modified-since' => Time.now.httpdate)
+    r.serve_file('helper.rb', base_path: __dir__)
+    assert_equal [
+      [:respond, @content, { 'etag' => @etag, 'last-modified' => @last_modified }]
+    ], r.response_calls
+  end
+
+  def test_serve_file_deflate
+    r = Qeweney.mock('accept-encoding' => 'deflate')
+    r.serve_file('helper.rb', base_path: __dir__)
+
+    deflate = Zlib::Deflate.new
+    deflated_content = deflate.deflate(@content, Zlib::FINISH)
+    
+    assert_equal [
+      [:respond, deflated_content, {
+        'etag' => @etag,
+        'last-modified' => @last_modified,
+        'vary' => 'Accept-Encoding',
+        'content-encoding' => 'deflate'
+      }]
+    ], r.response_calls
+  end
+
+  def test_serve_file_gzip
+    r = Qeweney.mock('accept-encoding' => 'gzip')
+    r.serve_file('helper.rb', base_path: __dir__)
+
+    buf = StringIO.new
+    z = Zlib::GzipWriter.new(buf)
+    z << @content
+    z.flush
+    z.close
+    gzipped_content = buf.string
+    
+    assert_equal [
+      [:respond, gzipped_content, {
+        'etag' => @etag,
+        'last-modified' => @last_modified,
+        'vary' => 'Accept-Encoding',
+        'content-encoding' => 'gzip'
+      }]
+    ], r.response_calls
+  end
+
+  def test_serve_file_non_existent
+    r = Qeweney.mock
+    r.serve_file('foo.rb', base_path: __dir__)
+    assert_equal [
+      [:respond, nil, { ':status' => Qeweney::Status::NOT_FOUND }]
+    ], r.response_calls
+  end
+end
+
+class UpgradeTest < MiniTest::Test
+  def test_upgrade
+    r = Qeweney.mock
+    r.upgrade('df')
+
+    assert_equal [
+      [:respond, nil, {
+        ':status' => 101,
+        'Upgrade' => 'df',
+        'Connection' => 'upgrade'
+      }]
+    ], r.response_calls
+
+  
+    r = Qeweney.mock
+    r.upgrade('df', { 'foo' => 'bar' })
+
+    assert_equal [
+      [:respond, nil, {
+        ':status' => 101,
+        'Upgrade' => 'df',
+        'Connection' => 'upgrade',
+        'foo' => 'bar'
+      }]
+    ], r.response_calls
+  end
+
+  def test_websocket_upgrade
+    r = Qeweney.mock(
+      'connection' => 'upgrade',
+      'upgrade' => 'websocket',
+      'sec-websocket-version' => '23',
+      'sec-websocket-key' => 'abcdefghij'
+    )
+    
+    assert_equal 'websocket', r.upgrade_protocol
+
+    r.upgrade_to_websocket('foo' => 'baz')
+    accept = Digest::SHA1.base64digest('abcdefghij258EAFA5-E914-47DA-95CA-C5AB0DC85B11')
+
+    assert_equal [
+      [:respond, nil, {
+        ':status' => 101,
+        'Upgrade' => 'websocket',
+        'Connection' => 'upgrade',
+        'foo' => 'baz',
+        'Sec-WebSocket-Accept' => accept
+      }],
+      [:websocket_connection, r]
+    ], r.response_calls
+  end
+end
+
+class ServeRackTest < MiniTest::Test
+  def test_serve_rack
+    r = Qeweney.mock(
+      ':method' => 'get',
+      ':path' => '/foo/bar?a=1&b=2%2F3',
+      'accept' => 'blah'
+    )
+    r.serve_rack(->(env) {
+      [404, {'Foo' => 'Bar'}, ["#{env['REQUEST_METHOD']} #{env['PATH_INFO']}"]]
+    })
+
+    assert_equal [
+      [:respond, "get /foo/bar", {':status' => 404, 'Foo' => 'Bar' }]
+    ], r.response_calls
+  end
+end

data/test/test_routing.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class RoutingTest < MiniTest::Test
+  App1 = ->(r) do
+    r.route do
+      r.on_root { r.redirect '/hello' }
+      r.on('hello') do
+        r.on_get('world') { r.respond 'Hello world' }
+        r.on_get { r.respond 'Hello' }
+        r.on_post do
+          r.redirect '/'
+        end
+      end
+    end
+  end
+
+  def test_app1
+    r = Qeweney.mock(':path' => '/foo')
+    App1.(r)
+    assert_equal [[:respond, nil, { ':status' => 404 }]], r.response_calls
+
+    r = Qeweney.mock(':path' => '/')
+    App1.(r)
+    assert_equal [[:respond, nil, { ':status' => 302, 'Location' => '/hello' }]], r.response_calls
+
+    r = Qeweney.mock(':path' => '/hello', ':method' => 'foo')
+    App1.(r)
+    assert_equal [[:respond, nil, { ':status' => 404 }]], r.response_calls
+
+    r = Qeweney.mock(':path' => '/hello', ':method' => 'get')
+    App1.(r)
+    assert_equal [[:respond, 'Hello', {}]], r.response_calls
+
+    r = Qeweney.mock(':path' => '/hello', ':method' => 'post')
+    App1.(r)
+    assert_equal [[:respond, nil, { ':status' => 302, 'Location' => '/' }]], r.response_calls
+
+    r = Qeweney.mock(':path' => '/hello/world', ':method' => 'get')
+    App1.(r)
+    assert_equal [[:respond, 'Hello world', {}]], r.response_calls
+  end
+
+  def test_on_root
+    app = Qeweney.route do |r|
+      r.on_root { r.respond('root') }
+      r.on('foo') {
+        r.on_root { r.respond('foo root') }
+        r.on('bar') {
+          r.on_root { r.respond('bar root') }
+          r.on('baz') {
+            r.on_root { r.respond('baz root') }
+          }
+        }
+      }
+    end
+
+    r = Qeweney.mock(':path' => '/')
+    app.(r)
+    assert_equal [[:respond, 'root', {}]], r.response_calls
+
+    r = Qeweney.mock(':path' => '/foo')
+    app.(r)
+    assert_equal [[:respond, 'foo root', {}]], r.response_calls
+
+    r = Qeweney.mock(':path' => '/foo/bar')
+    app.(r)
+    assert_equal [[:respond, 'bar root', {}]], r.response_calls
+
+    r = Qeweney.mock(':path' => '/foo/bar/baz')
+    app.(r)
+    assert_equal [[:respond, 'baz root', {}]], r.response_calls
+  end
+
+  def test_relative_path
+    app = Qeweney.route do |r|
+      r.on_root { r.respond('root') }
+      r.on('foo') { r.respond(File.join('FOO', r.route_relative_path)) }
+      r.on('bar') { 
+        r.on('baz') { r.respond(File.join('BAR/BAZ', r.route_relative_path)) }
+        r.default { r.respond(File.join('BAR', r.route_relative_path)) }
+      }
+    end
+
+    r = Qeweney.mock(':path' => '/foo/bar/baz')
+    app.(r)
+    assert_equal [[:respond, 'FOO/bar/baz', {}]], r.response_calls
+
+    r = Qeweney.mock(':path' => '/bar/a/b/c')
+    app.(r)
+    assert_equal [[:respond, 'BAR/a/b/c', {}]], r.response_calls
+
+    r = Qeweney.mock(':path' => '/bar/baz/b/c')
+    app.(r)
+    assert_equal [[:respond, 'BAR/BAZ/b/c', {}]], r.response_calls
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: qeweney
 version: !ruby/object:Gem::Version
-  version: '0.2'
+  version: '0.7'
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-02-11 00:00:00.000000000 Z
+date: 2021-03-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: escape_utils
@@ -66,6 +66,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 1.4.2
+- !ruby/object:Gem::Dependency
+  name: benchmark-ips
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.8.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.8.3
 description: 
 email: sharon@noteflakes.com
 executables: []
@@ -81,16 +95,23 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- TODO.md
+- examples/routing_benchmark.rb
 - lib/qeweney.rb
+- lib/qeweney/mime_types.rb
+- lib/qeweney/rack.rb
 - lib/qeweney/request.rb
 - lib/qeweney/request_info.rb
 - lib/qeweney/response.rb
 - lib/qeweney/routing.rb
+- lib/qeweney/status.rb
 - lib/qeweney/version.rb
 - qeweney.gemspec
 - test/helper.rb
 - test/run.rb
-- test/test_request.rb
+- test/test_request_info.rb
+- test/test_response.rb
+- test/test_routing.rb
 homepage: http://github.com/digital-fabric/qeweney
 licenses:
 - MIT