landline 0.9.2 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8cfe9c90223c0d5d2fdc054e3aa2f96e76cdfeada0e865e13ef72d87b08526ff
-  data.tar.gz: 5a3b62e85bdafa0f9470f42d6c6789c32a4eaf9f00df686188837c3b13c570ff
+  metadata.gz: 3032701a4da46a02233ca8b0f1a6c48a484dc068de78b0b82ea15381bc7950f1
+  data.tar.gz: ab0eba5a84fb6ba20fff26baf741cdd249c018cb74301b682d74b9d8b8bc043d
 SHA512:
-  metadata.gz: f89f80cab3f587d952a3aaca92fce4f715d7778475ffc7c36abc207b6e377a233d8450e8b051013c6bcd7c77f9271fbdf0c48b336e0961f0841437fb7fef4f07
-  data.tar.gz: 49a13a596296b21c9a8abedc9f1aaf479f7bdda3a20e0eeff874c2cb92f064df577e6b14067b31765cb4aeddbea46c35a54804a8ce77be66f47cdbf22b371a80
+  metadata.gz: a60a9110562ad5098f1bb3b93daf6449df72ff1bacb08ea6bc93684e528e7787fde92c53cd3d7ac1da5b800dada5672224329e72d31acf6b092a30208e463b61
+  data.tar.gz: ed7cf7655fe04a805da5079d793a4c2102b926d6d854206991c706221b65ca3f50c1dd441c223aca34196b713adb58ad92a642146302bd0480c2197affd29383

data/HACKING.md

@@ -23,8 +23,3 @@ To keep things beautiful, consider following recommendations:
 - Document classes as if the next maintainer after you has you at gunpoint.
   Document thoroughly, use YARD tags and **never** skip on public method
   docs and class docs. As an example, consider Landline::PatternMatching::Glob.
-- Unit tests suck for many reasons. However, if you're writing a class that
-  does not have any dependents and which is frequently used, consider making
-  a unit test for it. People that might have to fix things further along
-  will be very thankful.
-

data/LAYOUT.md

@@ -8,15 +8,17 @@ layout as closely as possible.
 These are core classes of Landline and they are loaded as soon as the library is loaded.
 
 - Landline::Path [path.rb]
-- Landline::PathBinding [path.rb]
+- Landline::PathContext [path.rb]
 - Landline::Probe [probe.rb]
-- Landline::ProbeBinding [probe.rb]
+- Landline::ProbeContext [probe.rb]
 - Landline::Node (parent of Path and Probe) [node.rb]
 - Landline::Server (Rack application interface) [server.rb]
-- Landline::ServerBinding [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
 
@@ -29,31 +31,56 @@ These are classes that Landline::Pattern can interface with to create Patterns.
 
 These are module mixins that add common methods to DSL bindings.
 
-- Landline::DSL::PathConstructors [dsl/path\_constructors.rb]
+- 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::Handler [probe/handler.rb]
-- Landline::GETHandler [probe/http\_method.rb]
-- Landline::POSTHandler [probe/http\_method.rb]
-- Landline::HEADHandler [probe/http\_method.rb]
-- Landline::PUTHandler [probe/http\_method.rb]
-- Landline::DELETEHandler [probe/http\_method.rb]
-- Landline::CONNECTHandler [probe/http\_method.rb]
-- Landline::OPTIONSHandler [probe/http\_method.rb]
-- Landline::TRACEHandler [probe/http\_method.rb]
-- Landline::PATCHHandler [probe/http\_method.rb]
+- 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]

data/README.md

@@ -142,7 +142,7 @@ For things to render correctly, please install the `redcarpet` gem.
 
 ```plain
     Landline - an HTTP request pattern matching system 
-    Copyright (C) 2022 yessiest (yessiest@memeware.net)
+    Copyright (C) 2022 yessiest (yessiest@text.512mb.org)
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by

data/lib/landline/dsl/constructors_probe.rb

@@ -5,23 +5,25 @@ module Landline
     # Probe (and subclasses) DSL construct
     module ProbeConstructors
       # Create a new erb template
-      # @see {Landline::Template#new}
+      # @see Landline::Template#new
       def erb(input, vars = {})
         Landline::Templates::ERB.new(input,
-                                 vars,
-                                 parent: @origin)
+                                     vars,
+                                     parent: @origin,
+                                     filename: caller_locations[0].path)
       end
 
       # Create a new erb template using Erubi engine
-      # @see {Landline::Template#new}
+      # @see Landline::Template#new
       # @param freeze [Boolean] whether to use frozen string literal
       # @param capture [Boolean] whether to enable output capturing
       def erubi(input, vars = {}, freeze: true, capture: false)
         Landline::Templates::Erubi.new(input,
-                                   vars,
-                                   parent: @origin,
-                                   freeze: freeze,
-                                   capture: capture)
+                                       vars,
+                                       parent: @origin,
+                                       freeze: freeze,
+                                       capture: capture,
+                                       filename: caller_locations[0].path)
       end
     end
   end

data/lib/landline/dsl/methods_path.rb

@@ -5,6 +5,27 @@ module Landline
   module DSL
     # Common path methods
     module PathMethods
+      # Bounce request if no handler found instead of issuing 404
+      def bounce
+        @origin.bounce = true
+      end
+
+      # Create a status code handler on path.
+      # Recursively applies to all paths unless overridden.
+      # @param code [Integer, nil] Specify a status code to handle
+      # @param block [#call] Block to run on given code
+      def handle(code = nil, &block)
+        @origin.properties["handle.#{code || 'default'}"] = block
+      end
+
+      # Insert a pass-through pipeline into request processing
+      # (i.e. for error handling purposes).
+      # Passed block should yield request (and return yielded data back).
+      # @param block [#call] block that yields request
+      def pipeline(&block)
+        @origin.pipeline = block
+      end
+
       # Set path index
       # @param index [Array,String]
       def index(index)
@@ -67,7 +88,9 @@ module Landline
 
           object
         end
-        @origin.children.append(self.instance_eval(File.read(filename)))
+        @origin.children.append(
+          self.instance_eval(File.read(filename), filename)
+        )
         self.singleton_class.undef_method :run
       end
     end

data/lib/landline/dsl/methods_template.rb

@@ -8,8 +8,17 @@ module Landline
     # Common methods for template contexts
     module TemplateMethods
       # Import a template part
+      # @param filepath [String, File] path to the file (or the file itself)
+      # @return [String] compiled template
       def import(filepath)
-        @parent_template.import(file(filepath)).run
+        template = if filepath.is_a? File
+                     filepath
+                   elsif filepath.start_with? "/"
+                     File.open(filepath)
+                   else
+                     file(filepath)
+                   end
+        @parent_template.import(template).run
       end
     end
   end

data/lib/landline/node.rb

@@ -35,7 +35,7 @@ module Landline
     end
 
     # Try to navigate the path. Run method callback in response.
-    # @param [Landline::Request]
+    # @param request [Landline::Request]
     # @return [Boolean]
     def go(request)
       # rejected at pattern
@@ -43,7 +43,8 @@ module Landline
 
       request.push_state
       path, splat, param = @pattern.match(request.path)
-      do_filepath(request, request.path.delete_suffix(path))
+      do_filepath(request, request.path.delete_suffix('/')
+                                       .delete_suffix(path))
       request.path = path
       request.splat.append(*splat)
       request.param.merge!(param)

data/lib/landline/path.rb

@@ -5,12 +5,16 @@ require_relative 'node'
 require_relative 'dsl/constructors_path'
 require_relative 'dsl/methods_path'
 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
@@ -54,21 +58,11 @@ module Landline
     # @return [Boolean] true if further navigation will be done
     # @raise [UncaughtThrowError] by default throws :response if no matches found.
     def process(request)
-      return false unless run_filters(request)
-
-      run_preprocessors(request)
-      enqueue_postprocessors(request)
-      @children.each do |x|
-        if (value = x.go(request))
-          return value
-        end
+      if @pipeline
+        @pipeline.call(request) { |inner_req| process_wrapped(inner_req) }
+      else
+        process_wrapped(request)
       end
-      value = index(request)
-      return value if value
-
-      _die(404)
-    rescue StandardError => e
-      _die(500, backtrace: [e.to_s] + e.backtrace)
     end
 
     # Add a preprocessor to the path.
@@ -95,7 +89,9 @@ module Landline
       @filters.append(block)
     end
 
-    attr_reader :children, :properties
+    attr_reader :children, :properties, :request
+
+    attr_accessor :bounce, :pipeline
 
     private
 
@@ -123,6 +119,31 @@ module Landline
       request.postprocessors.append(*@postprocessors)
     end
 
+    # Method callback on successful request navigation.
+    # Finds the next appropriate path to go to.
+    # (inner pipeline-wrapped handler)
+    # @return [Boolean] true if further navigation will be done
+    # @raise [UncaughtThrowError] by default throws :response if no matches found.
+    def process_wrapped(request)
+      @request = request
+      return false unless run_filters(request)
+
+      run_preprocessors(request)
+      enqueue_postprocessors(request)
+      @children.each do |x|
+        value = x.go(request)
+        return value if value
+      end
+      value = index(request)
+      return value if value
+
+      @bounce ? false : _die(404)
+    rescue StandardError => e
+      _die(500, backtrace: [e.to_s] + e.backtrace)
+    ensure
+      @request = nil
+    end
+
     # Try to perform indexing on the path if possible
     # @param request [Landline::Request]
     # @return [Boolean] true if indexing succeeded
@@ -146,11 +167,12 @@ module Landline
     # @raise [UncaughtThrowError] throws :finish to stop processing
     def _die(errorcode, backtrace: nil)
       throw :finish, [errorcode].append(
-        *(@properties["handle.#{errorcode}"] or
-          @properties["handle.default"]).call(
-            errorcode,
-            backtrace: backtrace
-          )
+        *@proccontext.instance_exec(
+          errorcode,
+          backtrace: backtrace,
+          &(@properties["handle.#{errorcode}"] or
+            @properties["handle.default"])
+        )
       )
     end
   end

data/lib/landline/pattern_matching/glob.rb

@@ -52,7 +52,7 @@ module Landline
     #     - underscores
     #     - dashes
     class Glob
-      # @param input [String] Glob pattern
+      # @param pattern [String] Glob pattern
       def initialize(pattern)
         pattern = Landline::PatternMatching.canonicalize(pattern)
         pieces = pattern.split(TOKENS)

data/lib/landline/pattern_matching/rematch.rb

@@ -39,7 +39,7 @@ module Landline
       end
 
       # Test if input is convertible and if it should be converted.
-      # @param input
+      # @param string [String] input to test conversion on
       # @return [Boolean] Input can be safely converted to Glob
       def self.can_convert?(string)
         string.is_a? Regexp

data/lib/landline/probe/handler.rb

@@ -7,7 +7,7 @@ module Landline
     # Probe that executes a callback on request
     class Handler < Landline::Probe
       # @param path [Object]
-      # @param parent [Landline::Node]
+      # @param args [Hash] hashed parameters to passthrough to Probe
       # @param exec [#call]
       def initialize(path, **args, &exec)
         super(path, **args)
@@ -15,10 +15,10 @@ module Landline
         @context = Landline::ProbeContext.new(self)
         @response = nil
       end
- 
+
       attr_accessor :response
       attr_reader :request
- 
+
       # Method callback on successful request navigation.
       # Runs block supplied with object initialization.
       # Request's #splat and #param are passed to block.

data/lib/landline/probe/serve_handler.rb

@@ -9,7 +9,6 @@ module Landline
     class Serve < Landline::Probe
       # @param path [Object]
       # @param parent [Landline::Node]
-      # @param exec [#call]
       def initialize(path, parent:)
         super(path, parent: parent, filepath: true)
       end

data/lib/landline/template/erb.rb

@@ -7,8 +7,8 @@ module Landline
   module Templates
     # ERB Template language adapter
     class ERB < Landline::Template
-      # @see {Landline::Template#new}
-      def initialize(input, vars = nil, parent:)
+      # (see Landline::Template#new)
+      def initialize(input, vars = nil, parent:, filename:)
         super
         varname = "_part_#{SecureRandom.hex(10)}".to_sym
         while @binding.local_variable_defined? varname
@@ -20,6 +20,7 @@ module Landline
 
       # Run the template.
       def run
+        @template.filename = @filename
         @template.result @binding
       end
     end

data/lib/landline/template/erubi.rb

@@ -7,29 +7,27 @@ module Landline
   module Templates
     # Erubi (ERB) template language adapter
     class Erubi < Landline::Template
-      # @see {Landline::Template#new}
+      # (see Landline::Template#new)
       def initialize(input,
                      vars = nil,
-                     parent:,
-                     freeze: true,
-                     capture: false)
-        super(input, vars, parent: parent)
+                     **ext)
+        super(input, vars, parent: ext[:parent], filename: ext[:filename])
         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
+          freeze: ext.fetch(:freeze, true)
         }
+        capture = ext.fetch(:capture, false)
         engine = capture ? ::Erubi::CaptureEndEngine : ::Erubi::Engine
         @template = engine.new(@template, properties)
       end
 
       # Run the template.
       def run
-        @binding.eval(@template.src)
+        @binding.eval(@template.src, @filename)
       end
     end
   end

data/lib/landline/template.rb

@@ -36,8 +36,13 @@ module Landline
     # @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
+    # @param filename [String] filename for eval if input is a string
+    def initialize(input, vars = {}, parent:, filename:)
+      @template, @filename = if input.is_a?(File)
+                               [input.read, input.path]
+                             else
+                               [input, filename]
+                             end
       @context = TemplateContext.new(parent, self)
       @parent = parent
       input.close if input.is_a? File
@@ -81,9 +86,14 @@ module Landline
       # ... (stub)
     end
 
-    # Import a template from within current template
-    def import(filepath)
-      newtemp = self.class.new(filepath, {}, parent: @parent)
+    # Import a template from within current template.
+    # @param file [File] template file to import
+    # @return [Landline::Template] loaded tempalte
+    def import(file)
+      newtemp = self.class.new(file,
+                               {},
+                               parent: @parent,
+                               filename: file.path)
       newtemp.binding = @binding
       newtemp
     end

data/lib/landline/util/mime.rb

@@ -1267,7 +1267,7 @@ module Landline
     }.freeze
 
     # Get MIME type by file extension
-    # @param ext [String] filename
+    # @param file [String] filename
     # @return [String] MIME type, defaults to "application/octet-stream"
     def self.get_mime_type(file)
       MIME[file.match(/\.(\w+)$/)&.[](1)] or "application/octet-stream"

data/lib/landline/util/multipart.rb

@@ -9,6 +9,8 @@ require_relative 'html'
 
 module Landline
   module Util
+    FormPart = Struct.new(:data, :name, :filename,
+                          :filetype, :tempfile, :headers)
     # Valid element of form data with headers
     # @!attribute headers [Hash] headers recevied from form data
     # @!attribute name [String] name of the form part
@@ -16,8 +18,7 @@ module Landline
     # @!attribute filename [String,nil] Original name of the sent file
     # @!attribute filetype [String,nil] MIME-type of the file
     # @!attribute tempfile [File,nil] Temporary file for storing sent file data.
-    FormPart = Struct.new(:data, :name, :filename,
-                          :filetype, :tempfile, :headers) do
+    class FormPart
       # Is this form part a file or plain data?
       # @return [Boolean]
       def file?
@@ -135,7 +136,8 @@ module Landline
       end
 
       # Setup file metadata
-      # @part part [FormPart]
+      # @param part [Landline::Util::FormPart]
+      # @return [void]
       def setup_file_meta(part)
         part.name = part.headers.dig("content-disposition", 1, "name")
         part.filename = part.headers.dig("content-disposition", 1, "filename")
@@ -144,7 +146,8 @@ module Landline
       end
 
       # Setup plain metadata
-      # @part part [FormPart]
+      # @param part [Landline::Util::FormPart]
+      # @return [void]
       def setup_data_meta(part)
         part.name = part.headers.dig("content-disposition", 1, "name")
       end

data/lib/landline.rb

@@ -10,10 +10,10 @@ require_relative 'landline/template'
 # Landline is a hideously simple ruby web framework
 module Landline
   # Landline version
-  VERSION = '0.9 "Moonsong" (beta/rewrite)'
+  VERSION = '0.10 "Node graph out of date. Rebuilding..." (beta)'
 
   # Landline branding and version
-  VLINE = "Landline/#{Landline::VERSION} (Ruby/#{RUBY_VERSION}/#{RUBY_RELEASE_DATE})\n"
+  VLINE = "Landline/#{Landline::VERSION} (Ruby/#{RUBY_VERSION}/#{RUBY_RELEASE_DATE})\n".freeze
 
   # Landline copyright
   COPYRIGHT = "Copyright 2023 Yessiest"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: landline
 version: !ruby/object:Gem::Version
-  version: 0.9.2
+  version: 0.10.0
 platform: ruby
 authors:
 - Yessiest
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-09-22 00:00:00.000000000 Z
+date: 2023-10-21 00:00:00.000000000 Z
 dependencies: []
 description: |
   Landline is a no-hard-dependencies HTTP routing DSL that was made entirely for fun.
@@ -71,7 +71,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 3.0.6
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="