syntropy 0.29.0 → 0.30.0

data/lib/syntropy/request/response.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+require 'time'
+require 'digest/sha1'
+
+require_relative '../http/status'
+require_relative '../mime_types'
+
+module Syntropy
+  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
+    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 = HTTP::FOUND)
+      respond(nil, ':status' => status, 'Location' => url)
+    end
+
+    def redirect_to_https(status = HTTP::MOVED_PERMANENTLY)
+      secure_uri = "https://#{host}#{uri}"
+      redirect(secure_uri, status)
+    end
+
+    def redirect_to_host(new_host, status = HTTP::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' => HTTP::NOT_MODIFIED,
+          'etag' => etag
+        })
+      end
+
+      mime_type = MimeTypes[File.extname(path)]
+      opts[:stat] = stat
+      (opts[:headers] ||= {})['Content-Type'] ||= mime_type if mime_type
+
+      respond_with_static_file(full_path, etag, last_modified, opts)
+    rescue Errno::ENOENT
+      respond(nil, ':status' => HTTP::NOT_FOUND)
+    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 respond_with_static_file(path, etag, last_modified, opts)
+      cache_headers = (etag || last_modified) ? {
+        'etag' => etag,
+        'last-modified' => last_modified
+      } : {}
+
+      adapter.respond_with_static_file(self, path, opts, cache_headers)
+    end
+
+    def set_response_headers(headers)
+      adapter.set_response_headers(headers)
+    end
+
+    def set_cookie(*)
+      adapter.set_cookie(*)
+    end
+
+    def upgrade(protocol, custom_headers = nil, &block)
+      upgrade_headers = {
+        ':status' => HTTP::SWITCHING_PROTOCOLS,
+        'Upgrade' => protocol,
+        'Connection' => 'upgrade'
+      }
+      upgrade_headers.merge!(custom_headers) if custom_headers
+
+      respond(nil, upgrade_headers)
+      adapter.with_stream(&block)
+    end
+
+    # Responds according to the given map. The given map defines the responses
+    # for each method. The value for each method is either an array containing
+    # the body and header values to use as response, or a proc returning such an
+    # array. For example:
+    #
+    #     req.respond_by_http_method(
+    #       'head'  => [nil, headers],
+    #       'get'   => -> { [IO.read(fn), headers] }
+    #     )
+    #
+    # If the request's method is not included in the given map, an exception is
+    # raised.
+    #
+    # @param map [Hash] hash mapping HTTP methods to responses
+    # @return [void]
+    def respond_by_http_method(map)
+      value = map[self.method]
+      raise Syntropy::Error.method_not_allowed if !value
+
+      value = value.() if value.is_a?(Proc)
+      (body, headers) = value
+      respond(body, headers)
+    end
+
+    # Responds to GET requests with the given body and headers. Otherwise raises
+    # an exception.
+    #
+    # @param body [String, nil] response body
+    # @param headers [Hash] response headers
+    # @return [void]
+    def respond_on_get(body, headers = {})
+      case self.method
+      when 'head'
+        respond(nil, headers)
+      when 'get'
+        respond(body, headers)
+      else
+        raise Syntropy::Error.method_not_allowed
+      end
+    end
+
+    # Responds to POST requests with the given body and headers. Otherwise
+    # raises an exception.
+    #
+    # @param body [String, nil] response body
+    # @param headers [Hash] response headers
+    # @return [void]
+    def respond_on_post(body, headers = {})
+      case self.method
+      when 'head'
+        respond(nil, headers)
+      when 'post'
+        respond(body, headers)
+      else
+      raise Syntropy::Error.method_not_allowed
+      end
+    end
+
+    def html_response(html, **headers)
+      respond(
+        html,
+        'Content-Type' => 'text/html; charset=utf-8',
+        **headers
+      )
+    end
+
+    def json_response(obj, **headers)
+      respond(
+        JSON.dump(obj),
+        'Content-Type' => 'application/json; charset=utf-8',
+        **headers
+      )
+    end
+
+    def json_pretty_response(obj, **headers)
+      respond(
+        JSON.pretty_generate(obj),
+        'Content-Type' => 'application/json; charset=utf-8',
+        **headers
+      )
+    end
+  end
+end

data/lib/syntropy/{request_extensions.rb → request/validation.rb}

@@ -1,60 +1,10 @@
 # frozen_string_literal: true
 
-require 'qeweney'
-require 'json'
-
-class Qeweney::Request
-  attr_accessor :start_stamp
-
-  def respond_with_static_file(path, etag, last_modified, opts)
-    cache_headers = (etag || last_modified) ? {
-      'etag' => etag,
-      'last-modified' => last_modified
-    } : {}
-
-    adapter.respond_with_static_file(self, path, opts, cache_headers)
-  end
-
-  def set_response_headers(headers)
-    adapter.set_response_headers(headers)
-  end
-
-  def set_cookie(*)
-    adapter.set_cookie(*)
-  end
-
-  def upgrade(protocol, custom_headers = nil, &block)
-    super(protocol, custom_headers)
-    adapter.with_stream(&block)
-  end
-end
+require 'uri'
+require 'escape_utils'
 
 module Syntropy
-  # Extensions for the Qeweney::Request class
-  module RequestExtensions
-    attr_reader :route_params
-    attr_accessor :route
-
-    # Initializes request with additional fields
-    def initialize(headers, adapter)
-      @headers  = headers
-      @adapter  = adapter
-      @route = nil
-      @route_params = {}
-      @ctx = nil
-    end
-
-    # Sets up mock request additional fields
-    def setup_mock_request
-      @route = nil
-      @route_params = {}
-      @ctx = nil
-    end
-
-    # Returns the request context
-    def ctx
-      @ctx ||= {}
-    end
+  module RequestValidationMethods
 
     # Checks the request's HTTP method against the given accepted values. If not
     # included in the accepted values, raises an exception. Otherwise, returns
@@ -68,64 +18,6 @@ module Syntropy
       raise Syntropy::Error.method_not_allowed
     end
 
-    # Responds according to the given map. The given map defines the responses
-    # for each method. The value for each method is either an array containing
-    # the body and header values to use as response, or a proc returning such an
-    # array. For example:
-    #
-    #     req.respond_by_http_method(
-    #       'head'  => [nil, headers],
-    #       'get'   => -> { [IO.read(fn), headers] }
-    #     )
-    #
-    # If the request's method is not included in the given map, an exception is
-    # raised.
-    #
-    # @param map [Hash] hash mapping HTTP methods to responses
-    # @return [void]
-    def respond_by_http_method(map)
-      value = map[self.method]
-      raise Syntropy::Error.method_not_allowed if !value
-
-      value = value.() if value.is_a?(Proc)
-      (body, headers) = value
-      respond(body, headers)
-    end
-
-    # Responds to GET requests with the given body and headers. Otherwise raises
-    # an exception.
-    #
-    # @param body [String, nil] response body
-    # @param headers [Hash] response headers
-    # @return [void]
-    def respond_on_get(body, headers = {})
-      case self.method
-      when 'head'
-        respond(nil, headers)
-      when 'get'
-        respond(body, headers)
-      else
-        raise Syntropy::Error.method_not_allowed
-      end
-    end
-
-    # Responds to POST requests with the given body and headers. Otherwise
-    # raises an exception.
-    #
-    # @param body [String, nil] response body
-    # @param headers [Hash] response headers
-    # @return [void]
-    def respond_on_post(body, headers = {})
-      case self.method
-      when 'head'
-        respond(nil, headers)
-      when 'post'
-        respond(body, headers)
-      else
-      raise Syntropy::Error.method_not_allowed
-      end
-    end
-
     # Validates and optionally converts request parameter value for the given
     # parameter name against the given clauses. If no clauses are given,
     # verifies the parameter value is not nil. A clause can be a class, such as
@@ -185,7 +77,7 @@ module Syntropy
         validated = true if client_mtime == last_modified
       end
       if validated
-        respond(nil, ':status' => Qeweney::Status::NOT_MODIFIED)
+        respond(nil, ':status' => HTTP::NOT_MODIFIED)
       else
         cache_headers = {
           'Cache-Control' => cache_control
@@ -197,67 +89,8 @@ module Syntropy
       end
     end
 
-    # Reads the request body and returns form data.
-    #
-    # @return [Hash] form data
-    def get_form_data
-      body = read
-      if !body || body.empty?
-        raise Syntropy::Error.new('Missing form data', Qeweney::Status::BAD_REQUEST)
-      end
-
-      Qeweney::Request.parse_form_data(body, headers)
-    rescue Qeweney::BadRequestError
-      raise Syntropy::Error.new('Invalid form data', Qeweney::Status::BAD_REQUEST)
-    end
-
-    def html_response(html, **headers)
-      respond(
-        html,
-        'Content-Type' => 'text/html; charset=utf-8',
-        **headers
-      )
-    end
-
-    def json_response(obj, **headers)
-      respond(
-        JSON.dump(obj),
-        'Content-Type' => 'application/json; charset=utf-8',
-        **headers
-      )
-    end
-
-    def json_pretty_response(obj, **headers)
-      respond(
-        JSON.pretty_generate(obj),
-        'Content-Type' => 'application/json; charset=utf-8',
-        **headers
-      )
-    end
-
-    def browser?
-      user_agent = headers['user-agent']
-      user_agent && user_agent =~ /^Mozilla\//
-    end
-
-    # Returns true if the accept header includes the given MIME type
-    #
-    # @param mime_type [String] MIME type
-    # @return [bool]
-    def accept?(mime_type)
-      accept = headers['accept']
-      return nil if !accept
-
-      @accept_parts ||= parse_accept_parts(accept)
-      @accept_parts.include?(mime_type)
-    end
-
     private
 
-    def parse_accept_parts(accept)
-      accept.split(',').map { it.match(/^\s*([^\s;]+)/)[1] }
-    end
-
     BOOL_REGEXP = /^(t|f|true|false|on|off|1|0|yes|no)$/
     BOOL_TRUE_REGEXP = /^(t|true|on|1|yes)$/
     INTEGER_REGEXP = /^[+-]?[0-9]+$/
@@ -304,5 +137,3 @@ module Syntropy
     end
   end
 end
-
-Qeweney::Request.include(Syntropy::RequestExtensions)

data/lib/syntropy/request.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require_relative './request/request_info'
+require_relative './request/validation'
+require_relative './request/response'
+require_relative './http/status'
+
+module Syntropy
+  class Request
+    include RequestInfoMethods
+    include RequestValidationMethods
+    include ResponseMethods
+
+    extend RequestInfoClassMethods
+
+    attr_reader :headers, :adapter, :start_stamp, :route_params
+    attr_accessor :route
+
+    def initialize(headers, adapter)
+      @headers  = headers
+      @adapter  = adapter
+      @start_stamp = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+      @route = nil
+      @route_params = {}
+      @ctx = nil
+    end
+
+    # Returns the request context
+    def ctx
+      @ctx ||= {}
+    end
+
+    def next_chunk
+      @adapter.get_body_chunk(self)
+    end
+
+    def each_chunk
+      while (chunk = @adapter.get_body_chunk(self))
+        yield chunk
+      end
+    end
+
+    def read
+      @adapter.get_body(self)
+    end
+    alias_method :body, :read
+
+    def complete?
+      @adapter.complete?(self)
+    end
+
+    EMPTY_HEADERS = {}.freeze
+
+    def respond(body, headers = EMPTY_HEADERS)
+      @adapter.respond(self, body, headers)
+      @headers_sent = true
+    end
+
+    def send_headers(headers = EMPTY_HEADERS, empty_response = false)
+      return if @headers_sent
+
+      @headers_sent = true
+      @adapter.send_headers(self, headers, empty_response: empty_response)
+    end
+
+    def send_chunk(body, done: false)
+      send_headers({}) unless @headers_sent
+
+      @adapter.send_chunk(self, body, done: done)
+    end
+    alias_method :<<, :send_chunk
+
+    def finish
+      send_headers({}) unless @headers_sent
+
+      @adapter.finish(self)
+    end
+
+    def headers_sent?
+      @headers_sent
+    end
+
+    def rx_incr(count)
+      headers[':rx'] ? headers[':rx'] += count : headers[':rx'] = count
+    end
+
+    def tx_incr(count)
+      headers[':tx'] ? headers[':tx'] += count : headers[':tx'] = count
+    end
+
+    def transfer_counts
+      [headers[':rx'], headers[':tx']]
+    end
+
+    def total_transfer
+      (headers[':rx'] || 0) + (headers[':tx'] || 0)
+    end
+  end
+end

data/lib/syntropy/utils.rb

@@ -20,7 +20,7 @@ module Syntropy
       #
       lambda { |req|
         site = sites[req.host]
-        site ? site.call(req) : req.respond(nil, ':status' => Status::BAD_REQUEST)
+        site ? site.call(req) : req.respond(nil, ':status' => HTTP::BAD_REQUEST)
       }
     end
 

data/lib/syntropy/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Syntropy
-  VERSION = '0.29.0'
+  VERSION = '0.30.0'
 end

data/lib/syntropy.rb

@@ -1,18 +1,17 @@
 # frozen_string_literal: true
 
-require 'qeweney'
 require 'uringmachine'
 require 'papercraft'
 
+require 'syntropy/request'
 require 'syntropy/logger'
-require 'syntropy/connection'
-require 'syntropy/server'
+require 'syntropy/http'
+require 'syntropy/mime_types'
 require 'syntropy/app'
 require 'syntropy/connection_pool'
 require 'syntropy/errors'
 require 'syntropy/markdown'
 require 'syntropy/module'
-require 'syntropy/request_extensions'
 require 'syntropy/papercraft_extensions'
 require 'syntropy/routing_tree'
 require 'syntropy/json_api'
@@ -21,8 +20,6 @@ require 'syntropy/utils'
 require 'syntropy/version'
 
 module Syntropy
-  Status = Qeweney::Status
-
   extend Utilities
 
   class << self

data/syntropy.gemspec

@@ -23,10 +23,9 @@ Gem::Specification.new do |s|
 
   s.add_dependency 'extralite',     '~>2.14'
   s.add_dependency 'papercraft',    '~>3.2.0'
-  s.add_dependency 'qeweney',       '~>0.24'
   s.add_dependency 'uringmachine',  '~>1.0.0'
-
-  s.add_dependency 'listen',        '~>3.9.0'
+  s.add_dependency 'cgi'
+  s.add_dependency 'escape_utils',  '1.3.0'
 
   s.add_dependency 'json'
   s.add_dependency 'logger'

data/test/app/about/_error.rb

@@ -1,4 +1,4 @@
-DEFAULT_STATUS = Qeweney::Status::INTERNAL_SERVER_ERROR
+DEFAULT_STATUS = HTTP::INTERNAL_SERVER_ERROR
 
 export ->(req, err) {
   status = err.respond_to?(:http_status) ? err.http_status : DEFAULT_STATUS

data/test/app/api+.rb

@@ -10,7 +10,7 @@ class API < Syntropy::JSONAPI
 
   def incr!(req)
     if req.path != '/test/api'
-        raise Syntropy::Error.new('Teapot', Qeweney::Status::TEAPOT)
+        raise Syntropy::Error.new('Teapot', HTTP::TEAPOT)
     end
 
     @count += 1

data/test/app_custom/_site.rb

@@ -1,3 +1,3 @@
 export ->(req) {
-  req.respond(nil, ':status' => Status::TEAPOT)
+  req.respond(nil, ':status' => HTTP::TEAPOT)
 }

data/test/bm_router_proc.rb

@@ -13,7 +13,7 @@ require 'roda'
 require 'benchmark/ips'
 require 'securerandom'
 require 'rack/mock_request'
-require 'qeweney/mock_adapter'
+require 'syntropy/request/mock_adapter'
 
 class BM
   def self.name(name)
@@ -100,7 +100,7 @@ p roda_app.(req)
 
 ################################################################################
 
-class Qeweney::Request
+class Syntropy::Request
   def response_headers
     adapter.headers
   end
@@ -157,7 +157,7 @@ proc = ->(req) { syntropy_app.(req) }
 
 module ::Kernel
   def mock_req(headers, body = nil)
-    Qeweney::MockAdapter.mock(headers, body).tap { it.setup_mock_request }
+    Syntropy::MockAdapter.mock(headers, body)
   end
 end
 

data/test/helper.rb

@@ -4,7 +4,7 @@ require 'bundler/setup'
 require_relative './coverage' if ENV['COVERAGE']
 require 'uringmachine'
 require 'syntropy'
-require 'qeweney/mock_adapter'
+require 'syntropy/request/mock_adapter'
 require 'minitest/autorun'
 require 'fileutils'
 
@@ -19,7 +19,7 @@ end
 
 module ::Kernel
   def mock_req(headers, body = nil)
-    Qeweney::MockAdapter.mock(headers, body).tap { it.setup_mock_request }
+    Syntropy::MockAdapter.mock(headers, body)
   end
 
   def capture_exception
@@ -89,15 +89,16 @@ module Minitest::Assertions
     return unless exp_content_type
 
     if Symbol === exp_content_type
-      exp_content_type = Qeweney::MimeTypes[exp_content_type]
+      exp_content_type = Syntropy::MimeTypes[exp_content_type]
     end
     actual = req.response_content_type
+
     assert_equal exp_content_type, actual
   end
 end
 
-# Extensions to be used in conjunction with `Qeweney::TestAdapter`
-class Qeweney::Request
+# Extensions to be used in conjunction with `Syntropy::TestAdapter`
+class Syntropy::Request
   def response_headers
     adapter.response_headers
   end