qeweney 0.5 → 0.7.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 82e2e4adbe7c5c163bb7252c666659baea7758f726a3426f9af837c0d09408ac
-  data.tar.gz: b7aee9e0c09876fd2730905dc61617945636bee6c3891bae45573f910aa67398
+  metadata.gz: 8410ab97bb9ce59f14cd87659fa5eeb77595f2a4a1fad873392e403d0b27a80a
+  data.tar.gz: 5b8404bf25b0b23cb72f0e3e919245d7f41361b692601f0e1bf5b208bc0215ed
 SHA512:
-  metadata.gz: 1225cb063c858b5e3f0e0e465d778771c8a8a4fec55d5b431d93489d637a8768c1787c1ea28aa6417f83d7666504e433bf338e48b483616d3b9165bb8e1f3465
-  data.tar.gz: 4fececba98bf9f24e0accef005c36eb62fe13bb5955e380b9324de71660c6dd156c1fb077a13051d1855b971a685be712f0e8873752cb414466974a15d8b8b4f
+  metadata.gz: 5ec5cb26a660c15cd465c04597c8135857f18b5cf8f706582243e3406f9163038c515d4d7a13678777ad71ab4c6fe26b11b35df8d27673316cf423f844c0529d
+  data.tar.gz: 85d6961f2eb42cf6d7299318e24dbf0ac697a89051667be99fc485b1359c0a0365eabeb69bbe2744d70bbefe9bcbce0226a1cf37196480defc7a6845572963e8

data/CHANGELOG.md

@@ -1,3 +1,16 @@
+## 0.7.3 2021-03-05
+
+- Fix `parse_urlencoded_form_data`
+
+## 0.7.2 2021-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

data/Gemfile.lock

@@ -1,13 +1,14 @@
 PATH
   remote: .
   specs:
-    qeweney (0.5)
+    qeweney (0.7.3)
       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/TODO.md

@@ -58,7 +58,7 @@ PAGES = Tipi::PageManager(
 
 app = Tipi.app do |r|
   r.on 'static' do
-    r.serve_file(r.routing_path, base_path: ASSETS_PATH)
+    r.serve_file(r.route_path, base_path: ASSETS_PATH)
   end
 
   r.default do

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Qeweney  
+module Qeweney
 end
 
 require_relative 'qeweney/request.rb'

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

@@ -138,7 +138,7 @@ module Qeweney
     MAX_PARAMETER_VALUE_SIZE = 2**20 # 1MB
 
     def parse_urlencoded_form_data(body)
-      body.force_encoding(UTF_8) unless body.encoding == Encoding::UTF_8
+      body.force_encoding(Encoding::UTF_8) unless body.encoding == Encoding::UTF_8
       body.split('&').each_with_object({}) do |i, m|
         raise 'Invalid parameter format' unless i =~ PARAMETER_RE
   

data/lib/qeweney/response.rb

@@ -142,5 +142,14 @@ module Qeweney
       )
       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,45 @@ 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.empty? ? '/' : "/#{@path_parts[@path_parts_idx..-1].join('/')}"
+    end
 
-        @__routing_path__ = Regexp.last_match(1) || '/'
+    def enter_route
+      @path_parts_idx += 1
+    end
+
+    def leave_route
+      @path_parts_idx -= 1
+    end
+
+    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

data/lib/qeweney/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Qeweney
-  VERSION = '0.5'
+  VERSION = '0.7.3'
 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

@@ -24,6 +24,8 @@ module Qeweney
   end
 
   def self.mock(headers = {})
+    headers[':method'] ||= ''
+    headers[':path'] ||= ''
     Request.new(headers, MockAdapter.new)
   end
 

data/test/test_response.rb

@@ -166,3 +166,20 @@ class UpgradeTest < MiniTest::Test
     ], 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,116 @@
+# 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
+    default_relative_path = nil
+
+    app = Qeweney.route do |r|
+      default_relative_path = r.route_relative_path
+      r.on_root { r.respond(File.join('ROOT', r.route_relative_path)) }
+      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)) }
+      }
+      r.on('baz') { r.respond(r.route_relative_path) }
+    end
+
+    r = Qeweney.mock(':path' => '/')
+    app.(r)
+    assert_equal '/', default_relative_path
+    assert_equal [[:respond, 'ROOT/', {}]], r.response_calls
+
+
+    r = Qeweney.mock(':path' => '/foo/bar/baz')
+    app.(r)
+    assert_equal '/foo/bar/baz', default_relative_path
+    assert_equal [[:respond, 'FOO/bar/baz', {}]], r.response_calls
+
+    r = Qeweney.mock(':path' => '/bar/a/b/c')
+    app.(r)
+    assert_equal '/bar/a/b/c', default_relative_path
+    assert_equal [[:respond, 'BAR/a/b/c', {}]], r.response_calls
+
+    r = Qeweney.mock(':path' => '/bar/baz/b/c')
+    app.(r)
+    assert_equal '/bar/baz/b/c', default_relative_path
+    assert_equal [[:respond, 'BAR/BAZ/b/c', {}]], r.response_calls
+
+    r = Qeweney.mock(':path' => '/baz/d/e/f')
+    app.(r)
+    assert_equal '/baz/d/e/f', default_relative_path
+    assert_equal [[:respond, '/d/e/f', {}]], r.response_calls
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: qeweney
 version: !ruby/object:Gem::Version
-  version: '0.5'
+  version: 0.7.3
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-02-15 00:00:00.000000000 Z
+date: 2021-03-05 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: []
@@ -82,8 +96,10 @@ files:
 - 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
@@ -95,6 +111,7 @@ files:
 - test/run.rb
 - test/test_request_info.rb
 - test/test_response.rb
+- test/test_routing.rb
 homepage: http://github.com/digital-fabric/qeweney
 licenses:
 - MIT