landline 0.9.2

data/lib/landline/request.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require 'uri'
+require_relative 'util/query'
+require_relative 'util/cookie'
+
+module Landline
+  # Request wrapper for Rack protocol
+  class Request
+    # @param env [Array]
+    def initialize(env)
+      # Should not be used under regular circumstances or depended upon.
+      @_original_env = env
+      # Rack environment variable bindings. Should be public and frozen.
+      init_request_params(env)
+      # Cookie hash
+      @cookies = Landline::Cookie.from_cookie_string(@headers['cookie'])
+      # Query parsing
+      @query = Landline::Util::Query.new(@query_string)
+      # Pattern matching parameters. Public, readable, unfrozen.
+      @param = {}
+      @splat = []
+      # Traversal route. Public and writable.
+      @path = URI.decode_www_form_component(env["PATH_INFO"].dup)
+      # File serving path. Public and writable.
+      @filepath = "/"
+      # Encapsulates all rack variables. Should not be public.
+      @rack = init_rack_vars(env)
+      # Internal navigation states. Private.
+      @states = []
+      # Postprocessors for current request
+      @postprocessors = []
+    end
+
+    # Run postprocessors
+    # @param response [Landline::Response]
+    def run_postprocessors(response)
+      @postprocessors.each do |postproc|
+        postproc.call(self, response)
+      end
+    end
+
+    # Returns request body (if POST data exists)
+    # @return [nil, String]
+    def body
+      @body ||= @rack.input&.read
+    end
+
+    # Returns raw Rack input object
+    # @return [IO] (May not entirely be compatible with IO, see Rack/SPEC.rdoc)
+    def input
+      @rack.input
+    end
+
+    # Push current navigation state (path, splat, param) onto state stack
+    def push_state
+      @states.push([@path, @param.dup, @splat.dup, @filepath.dup])
+    end
+
+    # Load last navigation state (path, splat, param) from state stack
+    def pop_state
+      @path, @param, @splat, @filepath = @states.pop
+    end
+
+    attr_reader :request_method, :script_name, :path_info, :server_name,
+                :server_port, :server_protocol, :headers, :param, :splat,
+                :postprocessors, :query, :cookies
+    attr_accessor :path, :filepath
+
+    private
+
+    # Initialize basic rack request parameters
+    # @param env [Hash]
+    def init_request_params(env)
+      @request_method = env["REQUEST_METHOD"]
+      @script_name = env["SCRIPT_NAME"]
+      @path_info = env["PATH_INFO"]
+      @query_string = env["QUERY_STRING"]
+      @server_name = env["SERVER_NAME"]
+      @server_port = env["SERVER_PORT"]
+      @server_protocol = env["SERVER_PROTOCOL"]
+      @headers = init_headers(env)
+    end
+
+    # Initialize rack parameters struct
+    # @param env [Hash]
+    # @return Object
+    def init_rack_vars(env)
+      rack_vars = env.filter_map do |k, v|
+        [k.delete_prefix("rack."), v] if k.start_with? "rack."
+      end.to_h
+      return if rack_vars.empty?
+
+      rack_vars["multipart"] = init_multipart_vars(env)
+      rack_keys = rack_vars.keys
+      rack_keys_sym = rack_keys.map(&:to_sym)
+      Struct.new(*rack_keys_sym)
+            .new(*rack_vars.values_at(*rack_keys))
+            .freeze
+    end
+
+    # Initialize multipart parameters struct
+    # @param env [Hash]
+    # @return Object
+    def init_multipart_vars(env)
+      multipart_vars = env.filter_map do |k, v|
+        if k.start_with? "rack.multipart"
+          [k.delete_prefix("rack.multipart."), v]
+        end
+      end.to_h
+      return if multipart_vars.empty?
+
+      multipart_keys = multipart_vars.keys
+      multipart_keys_sym = multipart_keys.map(&:to_sym)
+      Struct.new(*multipart_keys_sym)
+            .new(*multipart_vars.values_at(*multipart_keys))
+            .freeze
+    end
+
+    # Iniitalize headers hash
+    # @param env [Hash]
+    # @return Hash
+    def init_headers(env)
+      headers = env.filter_map do |name, value|
+        [name.delete_prefix("HTTP_"), value] if name.start_with?("HTTP_")
+      end.to_h
+      headers.merge!({ "CONTENT-TYPE" => env["CONTENT_TYPE"],
+                       "CONTENT-LENGTH" => env["CONTENT_LENGTH"],
+                       "REMOTE_ADDR" => env["REMOTE_ADDR"] })
+      headers.transform_keys do |x|
+        x.downcase.gsub("_", "-") if x.is_a? String
+      end.freeze
+    end
+  end
+end

data/lib/landline/response.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module Landline
+  # Rack protocol response wrapper.
+  class Response
+    @chunk_size = 1024
+
+    self.class.attr_accessor :chunk_size
+
+    # @param response [Array(Integer, Hash, Array), nil]
+    def initialize(response = nil)
+      @cookies = {}
+      if response
+        @status = response[0]
+        @headers = response[1]
+        @body = response[2]
+      else
+        @status = 200
+        @headers = {}
+        @body = []
+      end
+    end
+
+    # Return internal representation of Rack response
+    # @return [Array(Integer,Hash,Array)]
+    def finalize
+      @cookies.each do |_, cookie_array|
+        cookie_array.each do |cookie|
+          add_header("set-cookie", cookie.finalize)
+        end
+      end
+      [@status, @headers, @body]
+    end
+
+    # Make internal representation conformant
+    # @return [Landline::Response]
+    def validate
+      if [204, 304].include?(@status) or (100..199).include?(@status)
+        @headers.delete "content-length"
+        @headers.delete "content-type"
+        @body = []
+      elsif @headers.empty?
+        @headers = {
+          "content-length" => content_size,
+          "content-type" => "text/html"
+        }
+      end
+      @body = self.class.chunk_body(@body) if @body.is_a? String
+      self
+    end
+
+    # Add a cookie to the response
+    # @param cookie [Landline::Cookie]
+    def add_cookie(cookie)
+      if @cookies[cookie.key]
+        @cookies[cookie.key].append(cookie)
+      else
+        @cookies[cookie.key] = [cookie]
+      end
+    end
+
+    # Delete a cookie
+    # If no value is provided, deletes all cookies with the same key
+    # @param key [String] cookie key
+    # @param value [String, nil] cookie value
+    def delete_cookie(key, value)
+      if value
+        @cookies[key].delete(value)
+      else
+        @cookies.delete(key)
+      end
+    end
+
+    # Add a header to the headers hash
+    # @param key [String] header name
+    # @param value [String] header value
+    def add_header(key, value)
+      if @headers[key].is_a? String
+        @headers[key] = [@headers[key], value]
+      elsif @headers[key].is_a? Array
+        @headers[key].append(value)
+      else
+        @headers[key] = value
+      end
+    end
+
+    # Delete a header value from the headers hash
+    # If no value is provided, deletes all key entries
+    # @param key [String] header name
+    # @param value [String, nil] header value
+    def delete_header(key, value = nil)
+      if value and @headers[key].is_a? Array
+        @headers[key].delete(value)
+      else
+        @headers.delete(key)
+      end
+    end
+
+    attr_accessor :status, :headers, :body
+
+    # Ensure response correctness
+    # @param obj [String, Array, Landline::Response]
+    # @return Response
+    def self.convert(obj)
+      case obj
+      when Response
+        obj.validate
+      when Array
+        Response.new(obj).validate
+      when String, File, IO
+        Response.new([200,
+                      {
+                        "content-type" => "text/html"
+                      },
+                      obj]).validate
+      else
+        Response.new([404, {}, []])
+      end
+    end
+
+    # Turn body into array of chunks
+    # @param text [String]
+    # @return [Array(String)]
+    def self.chunk_body(text)
+      text.chars.each_slice(@chunk_size).map(&:join)
+    end
+
+    private
+
+    # Try to figure out content length
+    # @return [Integer, nil]
+    def content_size
+      case @body
+      when String then @body.bytesize
+      when Array then @body.join.bytesize
+      when File then @body.size
+      end
+    end
+  end
+end

data/lib/landline/server.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative 'path'
+require_relative 'request'
+require_relative 'util/html'
+
+module Landline
+  class ServerContext < Landline::PathContext
+  end
+
+  # A specialized path that can be used directly as a Rack application.
+  class Server < Landline::Path
+    Context = ServerContext
+
+    # @param parent [Landline::Node, nil] Parent object to inherit properties to
+    # @param setup [#call] Setup block
+    def initialize(parent: nil, **args, &setup)
+      super("", parent: nil, **args, &setup)
+      return if parent
+
+      {
+        "index" => [],
+        "handle.default" => proc do |code, backtrace: nil|
+          page = Landline::Util.default_error_page(code, backtrace)
+          headers = {
+            "content-length": page.bytesize,
+            "content-type": "text/html"
+          }
+          [headers, page]
+        end,
+        "path" => "/"
+      }.each { |k, v| @properties[k] = v unless @properties[k] }
+    end
+
+    # Rack ingress point.
+    # This should not be called under any circumstances twice in the same application,
+    # although server nesting for the purpose of creating virtual hosts is allowed.
+    # @param env [Hash]
+    # @return [Array(Integer,Hash,Array)]
+    def call(env)
+      request = Landline::Request.new(env)
+      response = catch(:finish) do
+        go(request)
+      end
+      request.run_postprocessors(response)
+      Response.convert(response).finalize
+    end
+  end
+end

data/lib/landline/template/erb.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'erb'
+require_relative '../template'
+
+module Landline
+  module Templates
+    # ERB Template language adapter
+    class ERB < Landline::Template
+      # @see {Landline::Template#new}
+      def initialize(input, vars = nil, parent:)
+        super
+        varname = "_part_#{SecureRandom.hex(10)}".to_sym
+        while @binding.local_variable_defined? varname
+          varname = "_part_#{SecureRandom.hex(10)}".to_sym
+        end
+        @template = ::ERB.new(@template, eoutvar: varname)
+        @template.filename = input.is_a?(File) ? input.path : "(Inline)"
+      end
+
+      # Run the template.
+      def run
+        @template.result @binding
+      end
+    end
+  end
+end

data/lib/landline/template/erubi.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'erubi'
+require_relative '../template'
+
+module Landline
+  module Templates
+    # Erubi (ERB) template language adapter
+    class Erubi < Landline::Template
+      # @see {Landline::Template#new}
+      def initialize(input,
+                     vars = nil,
+                     parent:,
+                     freeze: true,
+                     capture: false)
+        super(input, vars, parent: parent)
+        varname = "_part_#{SecureRandom.hex(10)}"
+        while @binding.local_variable_defined? varname.to_sym
+          varname = "_part_#{SecureRandom.hex(10)}"
+        end
+        properties = {
+          filename: input.is_a?(File) ? input.path : "(Inline)",
+          bufvar: varname,
+          freeze: freeze
+        }
+        engine = capture ? ::Erubi::CaptureEndEngine : ::Erubi::Engine
+        @template = engine.new(@template, properties)
+      end
+
+      # Run the template.
+      def run
+        @binding.eval(@template.src)
+      end
+    end
+  end
+end

data/lib/landline/template.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require_relative 'dsl/constructors_probe'
+require_relative 'dsl/methods_common'
+require_relative 'dsl/methods_probe'
+require_relative 'dsl/methods_template'
+
+module Landline
+  # All template engine adapters subclassed from Template
+  module Templates
+    autoload :ERB, "landline/template/erb"
+    autoload :Erubi, "landline/template/erubi"
+  end
+
+  # Context for template engines
+  class TemplateContext
+    include Landline::DSL::ProbeConstructors
+    include Landline::DSL::ProbeMethods
+    include Landline::DSL::CommonMethods
+    include Landline::DSL::TemplateMethods
+
+    # @return [Binding]
+    def binding
+      Kernel.binding
+    end
+
+    def initialize(parent, parent_template)
+      @origin = parent
+      @parent_template = parent_template
+    end
+  end
+
+  # Interface for Template engines
+  # @abstract does not represent any actual template engine.
+  class Template
+    # @param input [String, File] template text
+    # @param vars [Hash] local variables for tempalte
+    # @param parent [Landline::Node] parent node
+    def initialize(input, vars = {}, parent:)
+      @template = input.is_a?(File) ? input.read : input
+      @context = TemplateContext.new(parent, self)
+      @parent = parent
+      input.close if input.is_a? File
+      @binding = @context.binding
+      vars.each do |k, v|
+        @binding.local_variable_set(k, v)
+      end
+    end
+
+    # Set local variable
+    # @param key [Symbol]
+    # @param value [Object]
+    def local_variable_set(key, value)
+      @binding.local_variable_set(key, value)
+    end
+
+    # Get local variable
+    # @param key [Symbol]
+    # @return [Object]
+    def local_variable_get(key)
+      @binding.local_variable_get(key)
+    end
+
+    # Get an array of defined local variables
+    # @return [Array(Symbol)]
+    def local_variables
+      @binding.local_variables
+    end
+
+    # Override binding variables.
+    # @param vars [Hash{Symbol => Object}]
+    def override_locals(vars)
+      vars.each do |k, v|
+        @binding.local_variable_set(k, v)
+      end
+    end
+
+    # Run the template
+    # @note This method is a stub.
+    def run
+      # ... (stub)
+    end
+
+    # Import a template from within current template
+    def import(filepath)
+      newtemp = self.class.new(filepath, {}, parent: @parent)
+      newtemp.binding = @binding
+      newtemp
+    end
+
+    protected
+
+    attr_accessor :binding
+  end
+end

data/lib/landline/util/cookie.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require_relative 'parseutils'
+require_relative 'errors'
+require 'date'
+require 'openssl'
+HeaderRegexp = Landline::Util::HeaderRegexp
+ParserCommon = Landline::Util::ParserCommon
+
+module Landline
+  # Utility class for handling cookies
+  class Cookie
+    # @param key [String] cookie name
+    # @param value [String] cookie value
+    # @param params [Hash] cookie parameters
+    # @option params [String] "domain"
+    # @option params [String] "path"
+    # @option params [boolean, nil] "secure" (false)
+    # @option params [boolean, nil] "httponly" (false)
+    # @option params [String] "samesite"
+    # @option params [String, Integer] "max-age"
+    # @option params [String, Date] "expires"
+    # @raise Landline::ParsingError invalid cookie parameters
+    def initialize(key, value, params = {})
+      unless key.match? HeaderRegexp::COOKIE_NAME
+        raise Landline::ParsingError, "invalid cookie key: #{key}"
+      end
+
+      unless value.match? HeaderRegexp::COOKIE_VALUE
+        raise Landline::ParsingError, "invalid cookie value: #{value}"
+      end
+
+      # Make param keys strings
+      params.transform_keys!(&:to_s)
+
+      # Primary cookie parameters
+      @key = key
+      @value = value
+      setup_params(params)
+
+      # Cookie signing parameters
+      setup_hmac(params)
+    end
+
+    # Convert cookie to "Set-Cookie: " string representation.
+    # @return [String]
+    def finalize
+      sign(@hmac, algorithm: @algorithm, sep: @sep) if @hmac
+      ParserCommon.make_value(
+        "#{key.to_s.strip}=#{value.to_s.strip}",
+        {
+          "Domain" => @domain,
+          "Path" => @path,
+          "Expires" => @expires,
+          "Max-Age" => @maxage,
+          "SameSite" => @samesite,
+          "Secure" => @secure,
+          "HttpOnly" => @httponly
+        }
+      )
+    end
+
+    # Convert cookie to "Cookie: " string representation (no params)
+    # @return [String]
+    def finalize_short
+      sign(@hmac, algorithm: @algorithm, sep: @sep) if @hmac
+      "#{key.to_s.strip}=#{value.to_s.strip}"
+    end
+
+    # Sign the cookie value with HMAC
+    # @param key [String] HMAC signing key
+    # @param algorithm [String] Hash algorithm to use
+    # @param sep [String] Hash separator
+    def sign(key, algorithm: "sha256", sep: "&")
+      @value += sep + ::OpenSSL::HMAC.base64digest(algorithm, key, @value)
+    end
+
+    # Verify HMAC signature
+    # @param key [String] HMAC signing key
+    # @param algorithm [String] Hash algorithm
+    # @param sep [String] Hash separator
+    # @return [Boolean] whether value is signed and valid
+    def verify(key, algorithm: "sha256", sep: "&")
+      val, sig = @value.match(/\A(.*)#{sep}([A-Za-z0-9+\/=]+)\Z/).to_a[1..]
+      return false unless val and sig
+
+      sig == ::OpenSSL::HMAC.base64digest(algorithm, key, val)
+    end
+
+    attr_accessor :key, :value
+    attr_reader :domain, :path, :expires, :maxage, :samesite, :secure, :httponly
+
+    # Create cookie from a "Set-Cookie: " format
+    # @param data [String] value part of "Set-Cookie: " header
+    # @return [Cookie]
+    def self.from_setcookie_string(data)
+      kvpair, params = parse_value(data, regexp: HeaderRegexp::COOKIE_PARAM)
+      key, value = kvpair.match(/([^=]+)=?(.*)/).to_a[1..].map(&:strip)
+      Cookie.new(key, value, params)
+    end
+
+    # Create cookie(s) from a "Cookie: " format
+    # @param data [String] value part of "Cookie: " header
+    # @return [Hash{String => Cookie}]
+    def self.from_cookie_string(data)
+      hash = {}
+      return hash if data.nil?
+
+      data.split(";").map do |cookiestr|
+        key, value = cookiestr.match(/([^=]+)=?(.*)/).to_a[1..].map(&:strip)
+        cookie = Cookie.new(key, value)
+        if hash[cookie.key]
+          hash[cookie.key].append(cookie)
+        else
+          hash[cookie.key] = [cookie]
+        end
+      end
+      hash
+    end
+
+    private
+
+    def setup_hmac(params)
+      @hmac = params['hmac']
+      @algorithm = (params['algorithm'] or "sha256")
+      @sep = (params['sep'] or "&")
+    end
+
+    def setup_params(params)
+      # Extended cookie params
+      params.transform_keys!(&:downcase)
+      convert_date(params)
+      @domain = params['domain']&.remove_prefix(".")
+      @path = params['path']
+      @secure = !params['secure'].nil?
+      @httponly = !params['httponly'].nil?
+      @samesite = params['samesite'] or "None"
+    end
+
+    def convert_date(params)
+      maxage = params['max-age']
+      expires = params['expires']
+      @maxage = maxage.to_i if maxage&.match?(/\A\d+\z/)
+      @expires = case expires
+                 when Date then date.ctime(HeaderRegexp::RFC1123_DATE)
+                 when String then expires if Date.httpdate(expires)
+                 end
+    end
+  end
+end

data/lib/landline/util/errors.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Landline
+  # Generic error class, as recommended by Ruby documentation.
+  class Error < ::StandardError
+  end
+
+  # Error class raised by landline/util/parseutils module.
+  class ParsingError < Error
+  end
+end