landline 0.9.2

data/lib/landline/path.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require_relative 'pattern_matching'
+require_relative 'node'
+require_relative 'dsl/constructors_path'
+require_relative 'dsl/methods_path'
+require_relative 'dsl/methods_common'
+require_relative 'util/lookup'
+
+module Landline
+  # Execution context for filters and preprocessors.
+  class ProcessorContext
+    include Landline::DSL::CommonMethods
+
+    def initialize(path)
+      @origin = path
+    end
+  end
+
+  # Execution context for path setup block.
+  class PathContext
+    include Landline::DSL::PathConstructors
+    include Landline::DSL::PathMethods
+
+    def initialize(path)
+      @origin = path
+    end
+  end
+
+  # Primary building block of request navigation.
+  class Path < Landline::Node
+    ProcContext = Landline::ProcessorContext
+    Context = Landline::PathContext
+
+    # @param path [Object] Object to generate {Landline::Pattern} from
+    # @param parent [Landline::Node] Parent object to inherit properties to
+    # @param setup [#call] Setup block
+    def initialize(path, parent:, **params, &setup)
+      super(path, parent: parent, **params)
+      # Child nodes array
+      @children = []
+      # Arrays of preprocessors, postprocessors and filters
+      @preprocessors = []
+      @postprocessors = []
+      @filters = []
+      # Contexts setup
+      context = self.class::Context.new(self)
+      context.instance_exec(&setup)
+      @proccontext = self.class::ProcContext.new(self)
+    end
+
+    # Method callback on successful request navigation.
+    # Finds the next appropriate path to go to.
+    # @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
+      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.
+    # Does not modify path execution.
+    # @param block [#call]
+    # @yieldparam request [Landline::Request]
+    def preprocess(&block)
+      @preprocessors.append(block)
+    end
+
+    # Add a postprocessor to the path.
+    # @param block [#call]
+    # @yieldparam request [Landline::Request]
+    # @yieldparam response [Landline::Response]
+    def postprocess(&block)
+      @postprocessors.append(block)
+    end
+
+    # Add a filter to the path.
+    # Blocks path access if a filter returns false.
+    # @param block [#call]
+    # @yieldparam request [Landline::Request]
+    def filter(&block)
+      @filters.append(block)
+    end
+
+    attr_reader :children, :properties
+
+    private
+
+    # Sequentially run through all filters and drop request if one is false
+    # @param request [Landline::Request]
+    # @return [Boolean] true if request passed all filters
+    def run_filters(request)
+      @filters.each do |filter|
+        return false unless @proccontext.instance_exec(request, &filter)
+      end
+      true
+    end
+
+    # Sequentially run all preprocessors on a request
+    # @param request [Landline::Request]
+    def run_preprocessors(request)
+      @preprocessors.each do |preproc|
+        @proccontext.instance_exec(request, &preproc)
+      end
+    end
+
+    # Append postprocessors to request
+    # @param request [Landline::Request]
+    def enqueue_postprocessors(request)
+      request.postprocessors.append(*@postprocessors)
+    end
+
+    # Try to perform indexing on the path if possible
+    # @param request [Landline::Request]
+    # @return [Boolean] true if indexing succeeded
+    def index(request)
+      return false unless request.path.match?(/^\/?$/)
+
+      @properties["index"].each do |index|
+        request.path = index
+        @children.each do |x|
+          if (value = x.go(request))
+            return value
+          end
+        end
+      end
+      false
+    end
+
+    # Handle an errorcode
+    # @param errorcode [Integer]
+    # @param backtrace [Array(String), nil]
+    # @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
+          )
+      )
+    end
+  end
+end

data/lib/landline/pattern_matching/glob.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+module Landline
+  module PatternMatching
+    # someday i've heard this quote:
+    #   "if you love regexp so much why don't you marry the damn thing?"
+    # and so i did, as you can see here.
+
+    # Implements glob-like pattern matching.
+    # Exact specifications for globbing rules:
+    #
+    # "/"
+    #   - act as directory separators
+    #   - multiple slashes (i.e. "///") are the same as one slash ("/")
+    #   - slashes are stripped at start and end of an expression or path
+    #   - slashes are not matched by anything but the globstar ("**")
+    #
+    # "*" ( regexp: /([^/]*)/ )
+    #   - matches from 0 to any number of characters
+    #   - does not match nothing if placed between two slashes (i.e "/*/")
+    #   - result is captured in an array
+    #   - stops at slashes
+    #   - greedy (matches as much as possible)
+    #
+    # "**" ( regexp: /(.*)/ )
+    #   - matches any number of characters
+    #   - matches slashes ("/")
+    #   - result is captured in an array
+    #   - does not stop at slashes
+    #   - greedy (matches as much as possible)
+    #
+    # "[...]+" ( regexp: itself, ! and ^ at the start are interchangeable )
+    #   - acts like a regexp range
+    #   - matches any characters, including slashes if specified
+    #   - matches any number of characters
+    #   - valid ways to specify a range: [A-z], [a-z], [9-z] (ascii order)
+    #   - ! or ^ at the start invert meaning (any character not in range)
+    #   - result is captured in an array
+    #
+    # ":name" ( regexp: acts like a named group for /[^/]*/ )
+    #   - acts like * as defined above
+    #   - result is captured in a hash with "name" as key
+    #   - name allows alphanumeric characters and underscores
+    #   - ignored unless placed between two slashes
+    #
+    # "(name|name2|...)" ( regexp: itself )
+    #   - matches any of (full keywords) name, name2, ...
+    #   - result is captured in an array
+    #   - each name may include only these groups of characters:
+    #     - alphanumeric
+    #     - slashes
+    #     - underscores
+    #     - dashes
+    class Glob
+      # @param input [String] Glob pattern
+      def initialize(pattern)
+        pattern = Landline::PatternMatching.canonicalize(pattern)
+        pieces = pattern.split(TOKENS)
+        # @type [Array<String,Integer>]
+        @index = build_index(pieces)
+        # @type [Regexp]
+        @glob = build_regexp(pieces)
+      end
+
+      # Match the string and assign matches to parameters.
+      # Returns:
+      #
+      # - Unmatched part of a string
+      # - Unnamed parameters
+      # - Named parameters
+      # @param input [String] String to match
+      # @return [Array(String,Array,Hash)]
+      # @return [FalseClass] if input doesn't match glob
+      def match(input)
+        input = Landline::PatternMatching.canonicalize(input)
+        result = input.match(@glob)
+        return false unless result
+
+        input = result.post_match
+        named_params, params = assign_by_index(@index, result.captures)
+        [input, params, named_params]
+      end
+
+      # Test if a string can be matched.
+      # Lighter version of match that doesn't assign any variables.
+      # @param input [String] String to match
+      # @return [Boolean]
+      def match?(input)
+        input = Landline::PatternMatching.canonicalize(input)
+        input.match? @glob
+      end
+
+      # Test if input is convertible to a Glob and if it should be converted
+      # @param input
+      # @return [Boolean] Input can be safely converted to Glob
+      def self.can_convert?(input)
+        input.is_a? String and
+          input.match?(TOKENS)
+      end
+
+      private
+
+      # i shall name thee Norxondor Glorbulon
+
+      # Regexp pattern to match glob tokens
+      TOKENS = /
+        ( # Glob-specific tokens
+          (?<=(?:\/|^))\*\*(?:\/|$) |     # Freestanding globstar
+          \* |                            # Regular glob
+          \[!?\w-\w\]\+ |                 # Character group
+          (?<=\/):[\w_]+(?=(?:\/|$)) |    # Named glob
+          \([\w\/|_-]+\)                  # Alternator group
+        )
+      /x.freeze
+
+      # Build an index for separating normal matches from named matches
+      # @param pieces [Array(String)] Glob pattern after being splitted
+      # @return [Array(String,Integer)] Index array for assign_by_index
+      def build_index(pieces)
+        count = -1
+        index = []
+        pieces.each do |x|
+          if (name = x.match(/^:([\w_]+)$/))
+            index.append(name[1])
+          elsif x.match?(TOKENS)
+            index.append(count += 1)
+          end
+        end
+        index
+      end
+
+      # Assign values from match.captures to named and numbered groups
+      # @param index [Array(String,Integer)] Index array
+      # @param params [Array] Unnamed captures from a String.match
+      # @return [Array(Hash,Array)]
+      def assign_by_index(index, params)
+        named_params = {}
+        new_params = []
+        params.each_with_index do |x, k|
+          # FIXME: this is a hack for globstar implementation at line 152
+          x = (x.nil? ? "" : x)
+          if index[k].is_a? String
+            named_params[index[k].to_sym] = x
+          else
+            new_params[index[k]] = x
+          end
+        end
+        [named_params, new_params]
+      end
+
+      # Create a Regexp from a glob pattern according to defined syntax
+      # @param tokens [Array(String)] Split array of glob tokens
+      # @return [Regexp]
+      def build_regexp(tokens)
+        Regexp.new(tokens.map do |filter|
+          case filter
+          when /(\/|^)\*\*(\/|$)/ then "(?:(.*)/|)" # FIXME: this may return nil
+          when "*" then "([^/]*)"
+          when /^\([\w\/|_-]+\)$/ then filter.sub('-', '\\-')
+          when /^\[!?\w-\w\]\+$/ then filter.sub('!', '^')
+          when /^:[\w_]+$/ then "([^/]*)"
+          else filter.gsub(/[\^$.|+(){}]/, '\\\\\\0')
+          end
+        end.join("").prepend("^/?"))
+      end
+    end
+  end
+end

data/lib/landline/pattern_matching/rematch.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Landline
+  module PatternMatching
+    # Regexp pattern matching wrapper.
+    # Following principles apply to the wrapper:
+    #
+    # - Regexp input is canonicalized using Landline::PatternMatching.canonicalize
+    # - Matched content and anything before it is consumed in #match output
+    #
+    # @note If you are planning to write your own pattern, this is the easiest one to read.
+    class ReMatch
+      def initialize(pattern)
+        @glob = pattern
+      end
+
+      # Match the string and assign matches to parameters.
+      # Returns:
+      #
+      # - Unmatched part of a string
+      # - Unnamed parameters
+      # - Named parameters
+      # @param input [String] String to match
+      # @return [Array(String,Array,Hash)]
+      # @return [FalseClass] if input doesn't match regexp
+      def match(input)
+        result = Landline::PatternMatching.canonicalize(input).match(@glob)
+        return false unless result
+
+        [result.post_match, result.captures, result.named_captures]
+      end
+
+      # Test if a string can be matched.
+      # Lighter version of match that doesn't assign any variables.
+      # @param input [String] String to match
+      # @return [Boolean]
+      def match?(input)
+        Landline::PatternMatching.canonicalize(input).match? @glob
+      end
+
+      # Test if input is convertible and if it should be converted.
+      # @param input
+      # @return [Boolean] Input can be safely converted to Glob
+      def self.can_convert?(string)
+        string.is_a? Regexp
+      end
+    end
+  end
+end

data/lib/landline/pattern_matching/util.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Landline
+  module PatternMatching
+    # Strips extra slashes from a string.
+    # (including slashes at the start and end of the string)
+    # @param string [String]
+    # @return [String]
+    def self.canonicalize(string)
+      string.gsub(/\/+/, "/")
+            .delete_prefix("/")
+            .delete_suffix("/")
+    end
+  end
+end

data/lib/landline/pattern_matching.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative 'pattern_matching/util'
+require_relative 'pattern_matching/glob'
+require_relative 'pattern_matching/rematch'
+
+module Landline
+  # Utility functions and pattern-generator classes.
+  # Used primarily to create patterns for path definitions.
+  module PatternMatching end
+
+  # Delegate class for all available patterns.
+  # Picks appropriate pattern based on contents.
+  class Pattern
+    # @param pattern [Object] object to generate pattern from
+    def initialize(pattern)
+      @pattern = patternify(pattern)
+      @static = @pattern.is_a? String
+    end
+
+    # Checks if pattern object is static (is a simple String pattern).
+    def static?
+      @static
+    end
+
+    # Match the string and assign matches to parameters.
+    # Returns:
+    #
+    # - Unmatched part of a string
+    # - Unnamed parameters
+    # - Named parameters
+    # @param input [String] String to match
+    # @return [Array(String,Array,Hash)]
+    # @return [FalseClass] if input doesn't match pattern
+    def match(input)
+      if @pattern.is_a? String
+        input = Landline::PatternMatching.canonicalize(input)
+        if input.start_with?(@pattern)
+          [input.delete_prefix(@pattern), [], {}]
+        else
+          false
+        end
+      else
+        @pattern.match(input)
+      end
+    end
+
+    # Test if a string can be matched.
+    # Lighter version of match that doesn't assign any variables.
+    # @param input [String] String to match
+    # @return [Boolean]
+    def match?(input)
+      if @pattern.is_a? String
+        Landline::PatternMatching.canonicalize(input).start_with? @pattern
+      else
+        @pattern.match?(input)
+      end
+    end
+
+    private
+
+    def patternify(pattern)
+      classdomain = Landline::PatternMatching
+      classdomain.constants
+                 .filter { |x| classdomain.const_get(x).is_a? Class }
+                 .map { |x| classdomain.const_get(x) }
+                 .each do |pattern_generator|
+        if pattern_generator.can_convert? pattern
+          return pattern_generator.new(pattern)
+        end
+      end
+      Landline::PatternMatching.canonicalize(pattern)
+    end
+  end
+end

data/lib/landline/probe/handler.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative "../probe"
+
+module Landline
+  module Handlers
+    # Probe that executes a callback on request
+    class Handler < Landline::Probe
+      # @param path [Object]
+      # @param parent [Landline::Node]
+      # @param exec [#call]
+      def initialize(path, **args, &exec)
+        super(path, **args)
+        @callback = exec
+        @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.
+      #
+      # Callback's returned should be one of viable responses:
+      #
+      # - {Landline::Response} object
+      # - An array that matches Rack return form
+      # - An array that matches old (Rack 2.x) return form
+      # - A string (returned as HTML with code 200)
+      # - false (bounces the request to next handler)
+      # @param request [Landline::Request]
+      # @return [Boolean] true if further navigation is possible
+      # @raise [UncaughtThrowError] may raise if die() is called.
+      def process(request)
+        @response = nil
+        return reject(request) unless request.path.match?(/^\/?$/)
+ 
+        @request = request
+        response = catch(:break) do
+          @context.instance_exec(*request.splat,
+                                 **request.param,
+                                 &@callback)
+        end
+        return false unless response
+ 
+        if @response and [String, File, IO].include? response.class
+          @response.body = response
+          throw :finish, @response
+        end
+        throw :finish, response
+      end
+    end
+  end
+end

data/lib/landline/probe/http_method.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative "../probe"
+
+module Landline
+  module Handlers
+    # Probe that executes callback on a GET
+    class GET < Landline::Handlers::Handler
+      METHOD = "GET"
+
+      # Method callback on successful request navigation.
+      # Runs block supplied with object initialization.
+      # Request's #splat and #param are passed to block.
+      #
+      # Callback's returned should be one of viable responses:
+      #
+      # - {Landline::Response} object
+      # - An array that matches Rack return form
+      # - An array that matches old (Rack 2.x) return form
+      # - A string (returned as HTML with code 200)
+      # - false (bounces the request to next handler)
+      # @param request [Landline::Request]
+      # @return [Boolean] true if further navigation is possible
+      # @raise [UncaughtThrowError] may raise if die() is called.
+      def process(request)
+        unless request.request_method.casecmp(self.class::METHOD).zero?
+          return false
+        end
+
+        super(request)
+      end
+    end
+
+    # Probe that executes callback on a POST
+    class POST < GET
+      METHOD = "POST"
+    end
+
+    # Probe that executes callback on a HEAD
+    class HEAD < GET
+      METHOD = "HEAD"
+    end
+
+    # Probe that executes callback on a PUT
+    class PUT < GET
+      METHOD = "PUT"
+    end
+
+    # Probe that executes callback on a DELETE
+    class DELETE < GET
+      METHOD = "DELETE"
+    end
+
+    # Probe that executes callback on a CONNECT
+    class CONNECT < GET
+      METHOD = "CONNECT"
+    end
+
+    # Probe that executes callback on a OPTIONS
+    class OPTIONS < GET
+      METHOD = "OPTIONS"
+    end
+
+    # Probe that executes callback on a TRACE
+    class TRACE < GET
+      METHOD = "TRACE"
+    end
+
+    # Probe that executes callback on a PATCH
+    class PATCH < GET
+      METHOD = "PATCH"
+    end
+  end
+end

data/lib/landline/probe/serve_handler.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "../probe"
+require_relative "../util/mime"
+
+module Landline
+  module Handlers
+    # Probe that sends files from a location
+    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
+
+      attr_accessor :response
+
+      # Method callback on successful request navigation.
+      # Tries to serve files matched by handler
+      # @param request [Landline::Request]
+      # @return [Boolean, Array] true if file was found
+      def process(request)
+        path = File.expand_path(request.filepath)
+        return unless path.start_with? @properties["path"]
+
+        filepath = path.delete_suffix("/")
+
+        [200,
+         {
+           "content-type" => Landline::MIME.get_mime_type(filepath)
+         },
+         File.open(filepath)]
+      rescue StandardError
+        false
+      end
+    end
+  end
+end

data/lib/landline/probe.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative 'node'
+require_relative 'util/lookup'
+require_relative 'dsl/methods_probe'
+require_relative 'dsl/methods_common'
+require_relative 'dsl/constructors_probe'
+require 'pp'
+
+module Landline
+  # All subclasses of Landline::Probe that respond to requests
+  module Handlers
+    autoload :Handler, "landline/probe/handler"
+    autoload :GET, "landline/probe/http_method"
+    autoload :POST, "landline/probe/http_method"
+    autoload :HEAD, "landline/probe/http_method"
+    autoload :PUT, "landline/probe/http_method"
+    autoload :DELETE, "landline/probe/http_method"
+    autoload :CONNECT, "landline/probe/http_method"
+    autoload :OPTIONS, "landline/probe/http_method"
+    autoload :TRACE, "landline/probe/http_method"
+    autoload :PATCH, "landline/probe/http_method"
+    autoload :Serve, "landline/probe/serve_handler"
+  end
+
+  # Context that provides execution context for Probes.
+  class ProbeContext
+    include Landline::DSL::ProbeConstructors
+    include Landline::DSL::ProbeMethods
+    include Landline::DSL::CommonMethods
+
+    def initialize(origin)
+      @origin = origin
+    end
+  end
+
+  # Test probe. Also base for all "reactive" nodes.
+  class Probe < Landline::Node
+    # @param path [Object]
+    # @param parent [Landline::Node]
+    def initialize(path, parent:, **params)
+      super(path, parent: parent, **params)
+    end
+
+    attr_reader :properties
+
+    # Method callback on successful request navigation.
+    # Throws an error upon reaching the path.
+    # This behaviour should only be used internally.
+    # @param request [Landline::Request]
+    # @return [Boolean] true if further navigation is possible
+    # @raise [StandardError]
+    def process(request)
+      return reject(request) unless request.path.match?(/^\/?$/)
+
+      raise StandardError, <<~STREND
+        probe reached #{request.splat.inspect}, #{request.param.inspect}
+        #{request.pretty_inspect}
+      STREND
+    end
+  end
+end