landline 0.10.0 → 0.12.1

data/lib/landline/request.rb

@@ -3,6 +3,7 @@
 require 'uri'
 require_relative 'util/query'
 require_relative 'util/cookie'
+require_relative 'sandbox'
 
 module Landline
   # Request wrapper for Rack protocol
@@ -21,32 +22,38 @@ module Landline
       @param = {}
       @splat = []
       # Traversal route. Public and writable.
-      @path = URI.decode_www_form_component(env["PATH_INFO"].dup)
+      @path = URI.decode_www_form_component(env["PATH_INFO"])
       # File serving path. Public and writable.
       @filepath = "/"
-      # Encapsulates all rack variables. Should not be public.
+      # Encapsulates all rack variables. Is no longer private, but usually should not be used directly
       @rack = init_rack_vars(env)
       # Internal navigation states. Private.
       @states = []
       # Postprocessors for current request
       @postprocessors = []
+      # Execution context
+      @context = init_context
     end
 
     # Run postprocessors
     # @param response [Landline::Response]
     def run_postprocessors(response)
-      @postprocessors.each do |postproc|
-        postproc.call(self, response)
+      @context.origin.properties.lookup = {}
+      @postprocessors.reverse_each do |postproc|
+        @context.instance_exec(self, response, &postproc)
       end
+      @postprocessors = []
     end
 
     # Returns request body (if POST data exists)
+    # @note reads data from rack.input, which is not rewindable. .body data is memoized.
     # @return [nil, String]
     def body
       @body ||= @rack.input&.read
     end
 
     # Returns raw Rack input object
+    # @note Rack IO is not always rewindable - if it is read once, the data is gone (i.e. request.body will return nothing).
     # @return [IO] (May not entirely be compatible with IO, see Rack/SPEC.rdoc)
     def input
       @rack.input
@@ -62,13 +69,42 @@ module Landline
       @path, @param, @splat, @filepath = @states.pop
     end
 
+    # Checks if response stream can be partially hijacked
+    def hijack?
+      @_original_env['rack.hijack?']
+    end
+
+    # Returns full hijack callback
+    def hijack
+      @_original_env['rack.hijack']
+    end
+
+    # Reconstructs rack env after modification
+    def env
+      path = @path
+      @_original_env.merge(reconstruct_headers)
+                    .merge({
+                             'PATH_INFO' => path,
+                             'REQUEST_PATH' => path,
+                             'QUERY_STRING' => query.query,
+                             'REQUEST_URI' => "#{path}?#{query.query}"
+                           })
+                    .merge(reconstruct_cookie)
+    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
+                :postprocessors, :cookies, :rack, :context
+    attr_accessor :path, :filepath, :query
 
     private
 
+    # Initialize execution context
+    def init_context
+      origin = Landline::ProcessorOrigin.new(self, {})
+      Landline::ProcessorContext.new(origin)
+    end
+
     # Initialize basic rack request parameters
     # @param env [Hash]
     def init_request_params(env)
@@ -117,7 +153,7 @@ module Landline
             .freeze
     end
 
-    # Iniitalize headers hash
+    # Initialize headers hash
     # @param env [Hash]
     # @return Hash
     def init_headers(env)
@@ -131,5 +167,30 @@ module Landline
         x.downcase.gsub("_", "-") if x.is_a? String
       end.freeze
     end
+
+    # Reconstruct headers
+    def reconstruct_headers
+      @headers.filter_map do |k, v|
+        next unless v
+
+        if !['content-type', 'content-length',
+             'remote-addr'].include?(k) && (k.is_a? String)
+          k = "http_#{k}"
+        end
+        k = k.upcase.gsub("-", "_")
+        [k, v]
+      end.to_h
+    end
+
+    # Reconstruct cookie string
+    def reconstruct_cookie
+      return {} if @cookies.empty?
+
+      {
+        "HTTP_COOKIE" => @cookies.map do |_, v|
+          v.finalize_short
+        end.join(";")
+      }
+    end
   end
 end

data/lib/landline/response.rb

@@ -96,7 +96,7 @@ module Landline
       end
     end
 
-    attr_accessor :status, :headers, :body
+    attr_accessor :status, :headers, :body, :cookies
 
     # Ensure response correctness
     # @param obj [String, Array, Landline::Response]

data/lib/landline/sandbox.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'dsl/methods_common'
+require_relative 'dsl/methods_probe'
+require_relative 'dsl/constructors_probe'
+require_relative 'util/lookup'
+
+module Landline
+  # Execution context for filters and preprocessors.
+  class ProcessorContext
+    include Landline::DSL::CommonMethods
+    include Landline::DSL::ProbeMethods
+    include Landline::DSL::ProbeConstructors
+
+    def initialize(path)
+      @origin = path
+    end
+
+    attr_reader :origin
+  end
+
+  # Ephemeral proxy class to which callback execution binds
+  class ProcessorOrigin
+    def initialize(request, properties)
+      @request = request
+      @properties = Landline::Util::LookupROProxy.new(properties)
+    end
+
+    attr_accessor :response
+    attr_reader :request, :properties
+  end
+end

data/lib/landline/server.rb

@@ -11,39 +11,64 @@ module Landline
   # 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)
+    def initialize(passthrough = nil, parent: nil, **opts, &setup)
+      super("", parent: parent, **opts, &setup)
       return if parent
 
+      @passthrough = passthrough
+      setup_properties(parent: nil, **opts)
+    end
+
+    # Rack ingress point.
+    # @param env [Hash]
+    # @return [Array(Integer,Hash,Array)]
+    def call(env)
+      request = Landline::Request.new(env)
+
+      response = handle_jumps(request)
+      request.run_postprocessors(response)
+      resp = response.finalize
+      if resp[1][:"x-cascade"] and resp[0] == 404 and @passthrough
+        @passthrough.call(request.env)
+      else
+        resp
+      end
+    end
+
+    private
+
+    # Catch internal jumps
+    def handle_jumps(request)
+      response = Response.convert(catch(:finish) do
+        go(request)
+      end)
+      while response and
+            response.status == 307 and
+            response.headers.include? :"x-internal-jump"
+        response = Response.convert(catch(:finish) do
+          go(request)
+        end)
+      end
+      response
+    end
+
+    # Inititalization block for property setup
+    def setup_properties(*_args, **_opts)
       {
         "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"
+            "content-type": "text/html",
+            "x-cascade": true
           }
           [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/util/cookie.rb

@@ -4,9 +4,16 @@ require_relative 'parseutils'
 require_relative 'errors'
 require 'date'
 require 'openssl'
+require 'base64'
 HeaderRegexp = Landline::Util::HeaderRegexp
 ParserCommon = Landline::Util::ParserCommon
 
+if RUBY_ENGINE == 'jruby' # fix for JRuby
+  OpenSSL::HMAC.define_singleton_method(:base64digest) do |*args|
+    Base64.strict_encode64(OpenSSL::HMAC.digest(*args)).strip
+  end
+end
+
 module Landline
   # Utility class for handling cookies
   class Cookie
@@ -22,11 +29,11 @@ module Landline
     # @option params [String, Date] "expires"
     # @raise Landline::ParsingError invalid cookie parameters
     def initialize(key, value, params = {})
-      unless key.match? HeaderRegexp::COOKIE_NAME
+      unless key.match?(/\A#{HeaderRegexp::COOKIE_NAME}\z/o)
         raise Landline::ParsingError, "invalid cookie key: #{key}"
       end
 
-      unless value.match? HeaderRegexp::COOKIE_VALUE
+      unless value.match?(/\A#{HeaderRegexp::COOKIE_VALUE}\z/o)
         raise Landline::ParsingError, "invalid cookie value: #{value}"
       end
 
@@ -81,7 +88,7 @@ module Landline
     # @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..]
+      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)

data/lib/landline/util/jwt.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'openssl'
+require 'json'
+require 'base64'
+
+if RUBY_ENGINE == 'jruby' # fix for JRuby
+  OpenSSL::HMAC.define_singleton_method(:base64digest) do |*args|
+    Base64.strict_encode64(OpenSSL::HMAC.digest(*args)).strip
+  end
+end
+
+module Landline
+  module Util
+    # JSON Web Token construction class
+    class JWT
+      ALGO = {
+        "HS256" => proc do |data, secret|
+          Base64.urlsafe_encode64(
+            OpenSSL::HMAC.digest("SHA256", secret, data)
+          ).gsub('=', '')
+        end,
+        "HS384" => proc do |data, secret|
+          Base64.urlsafe_encode64(
+            OpenSSL::HMAC.digest("SHA384", secret, data)
+          ).gsub('=', '')
+        end,
+        "HS512" => proc do |data, secret|
+          Base64.urlsafe_encode64(
+            OpenSSL::HMAC.digest("SHA512", secret, data)
+          ).gsub('=', '')
+        end
+      }.freeze
+
+      # Create a new JWT token wrapper
+      # @param data [Hash, Array] JSON-formattable data
+      # @param halgo [String] Name of the hash algorithm to use
+      def initialize(data, halgo = "HS256")
+        unless ALGO.include? halgo
+          raise StandardError, "hash algorithm #{halgo} not supported"
+        end
+
+        @halgo = halgo
+        @data = data
+      end
+
+      # Construct a string representation of the current token
+      # @param key [String]
+      # @return [String]
+      def make(key)
+        jsonheader = {
+          "alg": @halgo,
+          "typ": "JWT"
+        }.to_json
+        jsondata = @data.to_json
+        data = "#{base64(jsonheader)}.#{base64(jsondata)}"
+        "#{data}.#{ALGO[@halgo].call(data, key)}"
+      end
+
+      # Construct an object from string
+      # @param input [String]
+      # @param key [String]
+      # @return [JWT, nil] returns nil if verification couldn't complete
+      def self.from_string(input, key)
+        halgoj, dataj, sig = input.split(".")
+        halgo = JSON.parse(Base64.urlsafe_decode64(halgoj))["alg"]
+        return nil unless ALGO.include? halgo
+        return nil if ALGO[halgo].call("#{halgoj}.#{dataj}", key) != sig
+
+        new(JSON.parse(Base64.urlsafe_decode64(dataj)), halgo)
+      end
+
+      attr_accessor :data
+
+      private
+
+      def base64(data)
+        Base64.urlsafe_encode64(data).gsub("=", "")
+      end
+    end
+  end
+end

data/lib/landline/util/lookup.rb

@@ -33,5 +33,21 @@ module Landline
 
       attr_accessor :parent
     end
+
+    # Read-only lookup proxy
+    class LookupROProxy
+      def initialize(lookup)
+        @lookup = lookup
+      end
+
+      # Get a value by key
+      # @param key [#hash] key for value
+      # @return [Object,nil]
+      def [](key)
+        @lookup.[](key)
+      end
+
+      attr_accessor :lookup
+    end
   end
 end

data/lib/landline/util/mime.rb

@@ -1267,6 +1267,7 @@ module Landline
     }.freeze
 
     # Get MIME type by file extension
+    # @note This function does no checks on the file - simply renaming the file to a different extension will yield an invalid result. Do not use this to check uploaded files - preferably, use libmagic or proper mime type tools for Ruby.
     # @param file [String] filename
     # @return [String] MIME type, defaults to "application/octet-stream"
     def self.get_mime_type(file)

data/lib/landline/util/parseutils.rb

@@ -8,28 +8,28 @@ module Landline
     # (not exactly precise) Regular expressions for some RFC definitions
     module HeaderRegexp
       # Matches the RFC2616 definiton of token
-      TOKEN = /[!-~&&[^()<>@,;:\\"\/\[\]?={}\t]]+/.freeze
+      TOKEN = /[!-~&&[^()<>@,;:\\"\/\[\]?={}\t]]+/
       # Matches the RFC2616 definition of quoted-string
-      QUOTED = /"[\x0-\x7E&&[^\x1-\x8\xb-\x1f]]*(?<!\\)"/.freeze
+      QUOTED = /"[\x0-\x7E&&[^\x1-\x8\xb-\x1f]]*(?<!\\)"/
       # Matches any CHAR except CTLs
-      PRINTCHAR = /[\x2-\x7E]/.freeze
+      PRINTCHAR = /[\x2-\x7E]/
       # Matches 1 or more CHARs excluding CTLs
-      PRINTABLE = /#{PRINTCHAR}+/o.freeze
+      PRINTABLE = /#{PRINTCHAR}+/o
       # Matches the RFC6265 definition of a cookie-octet
-      COOKIE_OCTET = /[\x21-\x7E&&[^",;\\]]*/.freeze
-      COOKIE_VALUE = /(?:#{QUOTED}|#{COOKIE_OCTET})/o.freeze
+      COOKIE_OCTET = /[\x21-\x7E&&[^",;\\]]*/
+      COOKIE_VALUE = /(?:#{QUOTED}|#{COOKIE_OCTET})/o
       COOKIE_NAME = TOKEN
       # Matches the RFC6265 definition of cookie-pair.
       # Captures name (1) and value (2).
-      COOKIE_PAIR = /\A(#{COOKIE_NAME})=(#{COOKIE_VALUE})\Z/o.freeze
+      COOKIE_PAIR = /\A(#{COOKIE_NAME})=(#{COOKIE_VALUE})\z/o
       # Matches a very abstract definition of a quoted header paramter.
       # Captures name (1) and value (2).
-      PARAM_QUOTED = /\A(#{TOKEN})=?(#{QUOTED}|#{PRINTCHAR}*)\Z/o.freeze
+      PARAM_QUOTED = /\A(#{TOKEN})=?(#{QUOTED}|#{PRINTCHAR}*)\z/o
       # Matches a very abstract definition of a header parameter.
       # Captures name (1) and value (2).
-      PARAM = /\A(#{TOKEN})=?(#{PRINTCHAR}*)\Z/o.freeze
+      PARAM = /\A(#{TOKEN})=?(#{PRINTCHAR}*)\z/o
       # Specifically matches cookie parameters
-      COOKIE_PARAM = /\A(#{TOKEN})=?(#{QUOTED}|#{COOKIE_OCTET})\Z/o.freeze
+      COOKIE_PARAM = /\A(#{TOKEN})=?(#{QUOTED}|#{COOKIE_OCTET})\z/o
     end
 
     # Module for all things related to parsing HTTP and related syntax.
@@ -48,7 +48,9 @@ module Landline
       # @param regexp [Regexp,nil] override param matching regexp
       # @return [Array(String, Hash)]
       def self.parse_value(input, sep: ";", unquote: false, regexp: nil)
-        parts = input.split(sep).map { |x| URI.decode_uri_component(x).strip }
+        parts = input.split(sep).map do |x|
+          URI.decode_www_form_component(x).strip
+        end
         base = parts.shift
         opts = parts.map do |raw|
           key, value = raw.match(if regexp

data/lib/landline/util/query.rb

@@ -8,6 +8,8 @@ module Landline
     # Query string parser
     class Query
       include Landline::Util::ParserSorting
+      attr_reader :query
+
       # @param query [String]
       def initialize(query)
         @query = query

data/lib/landline.rb

@@ -1,16 +1,18 @@
 # frozen_string_literal: true
 
+require_relative 'landline/util/jwt'
 require_relative 'landline/server'
 require_relative 'landline/path'
 require_relative 'landline/probe'
 require_relative 'landline/request'
 require_relative 'landline/response'
 require_relative 'landline/template'
+require_relative 'landline/app'
 
-# Landline is a hideously simple ruby web framework
+# Landline is a backend framework born as a by-product of experimentation
 module Landline
   # Landline version
-  VERSION = '0.10 "Node graph out of date. Rebuilding..." (beta)'
+  VERSION = '0.12.1 "Concrete and Gold" (pre-alpha)'
 
   # Landline branding and version
   VLINE = "Landline/#{Landline::VERSION} (Ruby/#{RUBY_VERSION}/#{RUBY_RELEASE_DATE})\n".freeze

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: landline
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.12.1
 platform: ruby
 authors:
 - Yessiest
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-10-21 00:00:00.000000000 Z
+date: 2024-05-07 00:00:00.000000000 Z
 dependencies: []
 description: |
   Landline is a no-hard-dependencies HTTP routing DSL that was made entirely for fun.
@@ -19,21 +19,22 @@ executables: []
 extensions: []
 extra_rdoc_files:
 - HACKING.md
-- LAYOUT.md
 - LICENSE.md
 - README.md
 files:
 - HACKING.md
-- LAYOUT.md
 - LICENSE.md
 - README.md
 - lib/landline.rb
+- lib/landline/app.rb
 - lib/landline/dsl/constructors_path.rb
 - lib/landline/dsl/constructors_probe.rb
 - lib/landline/dsl/methods_common.rb
 - lib/landline/dsl/methods_path.rb
 - lib/landline/dsl/methods_probe.rb
 - lib/landline/dsl/methods_template.rb
+- lib/landline/extensions/session.rb
+- lib/landline/extensions/websocket.rb
 - lib/landline/node.rb
 - lib/landline/path.rb
 - lib/landline/pattern_matching.rb
@@ -41,11 +42,13 @@ files:
 - lib/landline/pattern_matching/rematch.rb
 - lib/landline/pattern_matching/util.rb
 - lib/landline/probe.rb
+- lib/landline/probe/crosscall_handler.rb
 - lib/landline/probe/handler.rb
 - lib/landline/probe/http_method.rb
 - lib/landline/probe/serve_handler.rb
 - lib/landline/request.rb
 - lib/landline/response.rb
+- lib/landline/sandbox.rb
 - lib/landline/server.rb
 - lib/landline/template.rb
 - lib/landline/template/erb.rb
@@ -53,6 +56,7 @@ files:
 - lib/landline/util/cookie.rb
 - lib/landline/util/errors.rb
 - lib/landline/util/html.rb
+- lib/landline/util/jwt.rb
 - lib/landline/util/lookup.rb
 - lib/landline/util/mime.rb
 - lib/landline/util/multipart.rb
@@ -61,7 +65,7 @@ files:
 - lib/landline/util/query.rb
 homepage: https://adastra7.net/git/Yessiest/landline
 licenses:
-- AGPL-3.0
+- AGPL-3.0-or-later
 metadata: {}
 post_install_message:
 rdoc_options: []
@@ -78,7 +82,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.25
+rubygems_version: 3.5.6
 signing_key:
 specification_version: 4
 summary: Elegant HTTP DSL

data/LAYOUT.md

@@ -1,86 +0,0 @@
-# Internal structure of Landline lib
-
-Note: If you want to start hacking on Landline and extending it, follow this
-layout as closely as possible.
-
-## Core classes
-
-These are core classes of Landline and they are loaded as soon as the library is loaded.
-
-- Landline::Path [path.rb]
-- Landline::PathContext [path.rb]
-- Landline::Probe [probe.rb]
-- Landline::ProbeContext [probe.rb]
-- Landline::Node (parent of Path and Probe) [node.rb]
-- Landline::Server (Rack application interface) [server.rb]
-- Landline::ServerContext [server.rb]
-- Landline::Request (Rack request wrapper) [request.rb]
-- Landline::Response (Rack response wrapper) [response.rb]
-- Landline::Pattern [pattern\_matching.rb]
-- Landline::TemplateContext [tempalte.rb]
-- Landline::Template (template engine interface) [template.rb]
-
-## Patterns
-
-These are classes that Landline::Pattern can interface with to create Patterns.
-
-- Landline::PatternMatching::ReMatch [pattern\_matching/rematch.rb]
-- Landline::PatternMatching::Glob [pattern\_matching/glob.rb]
-
-## DSL Method mixins
-
-These are module mixins that add common methods to DSL bindings.
-
-- Landline::DSL::PathConstructors [dsl/constructors\_path.rb]
-- Landline::DSL::ProbeConstructures [dsl/constructors\_probe.rb]
-- Landline::DSL::CommonMethods [dsl/methods\_common.rb]
-- Landline::DSL::PathMethods [dsl/methods\_path.rb]
-- Landline::DSL::ProbeMethods [dsl/methods\_probe.rb]
-- Landline::DSL::TemplateMethods [dsl/methods\_template.rb]
-
-## Utilities
-
-These are self-contained classes and methods that add extra functionality to Landline.
-
-- Landline::Util::Lookup [util/lookup.rb]
-- Landline::PatternMatching [pattern\_matching/util.rb]
-- Landline::Cookie (class) [util/cookie.rb]
-- Landline::Error (class) [util/errors.rb]
-- Landline::ParsingError (class) [util/errors.rb]
-- Landline::Util (html/http utilities) [util/html.rb]
-- Landline::MIME (MIME extension to type association) [util/mime.rb]
-- Landline::Util::ParserSorting (functions for sorting form/query hashes) [util/parsesorting.rb]
-- Landline::Util::Query (query class) [util/query.rb]
-- Landline::Util::FormPart (formparser struct) [util/multipart.rb]
-- Landline::Util::MultipartParser (multipart form parser) [util/multipart.rb]
-- Landline::Util::HeaderRegexp (helper regexps for headers) [util/parseutils.rb]
-- Landline::Util (parser methods) [util/parseutils.rb]
-
-## Probe subclasses
-
-These are reactive request handlers with their own semantics, if needed.
-
-- Landline::Handlers::Handler [probe/handler.rb]
-- Landline::Handlers::GETHandler [probe/http\_method.rb]
-- Landline::Handlers::POSTHandler [probe/http\_method.rb]
-- Landline::Handlers::HEADHandler [probe/http\_method.rb]
-- Landline::Handlers::PUTHandler [probe/http\_method.rb]
-- Landline::Handlers::DELETEHandler [probe/http\_method.rb]
-- Landline::Handlers::CONNECTHandler [probe/http\_method.rb]
-- Landline::Handlers::OPTIONSHandler [probe/http\_method.rb]
-- Landline::Handlers::TRACEHandler [probe/http\_method.rb]
-- Landline::Handlers::PATCHHandler [probe/http\_method.rb]
-- Landline::Handlers::Serve
-
-## Path subclasses
-
-These are navigation handlers with their own semantics.
-
-(currently none)
-
-## Template engine interfaces
-
-These are uniform interfaces for various templating engines.
-
-- Landline::Templates::ERB [template/erb.rb]
-- Landline::Templates::Erubi [template/erubi.rb]