landline 0.9.3 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 58106097aed53f3fb0edd51bf2d9ecf8ba9d976946ffd7e4570c7f1b5ecdafa7
-  data.tar.gz: 2b1a03b8a2afeb431a9afe0207a7f17a9ea5439372cccd2c7d2e02b50f544ff1
+  metadata.gz: 3032701a4da46a02233ca8b0f1a6c48a484dc068de78b0b82ea15381bc7950f1
+  data.tar.gz: ab0eba5a84fb6ba20fff26baf741cdd249c018cb74301b682d74b9d8b8bc043d
 SHA512:
-  metadata.gz: 9422f97e4310cea957b3c8ee6aed9ecc279bdffbb3e8578263a1f03316881d2833a3e3bdac42816a077702d3501d7c71027d6e7f5d72a8e1cf34ca4e114f66b8
-  data.tar.gz: ea8a961e1a6cbb755a8be74c75288932c736174fdef1a7c04c5ef5f6d5d3e0687f393ff5076a8435c1e6eb57978c4993f0152a38af5e5ec77c99adfdedfffe6c
+  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/lib/landline/dsl/constructors_probe.rb

@@ -5,7 +5,7 @@ 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,
@@ -14,7 +14,7 @@ module Landline
       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)

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)

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,7 +7,7 @@ module Landline
   module Templates
     # ERB Template language adapter
     class ERB < Landline::Template
-      # @see {Landline::Template#new}
+      # (see Landline::Template#new)
       def initialize(input, vars = nil, parent:, filename:)
         super
         varname = "_part_#{SecureRandom.hex(10)}".to_sym

data/lib/landline/template/erubi.rb

@@ -7,7 +7,7 @@ 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,
                      **ext)

data/lib/landline/template.rb

@@ -86,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.3
+  version: 0.10.0
 platform: ruby
 authors:
 - Yessiest
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-09-25 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.