wayfarer 0.4.7 → 0.4.8

data/lib/wayfarer/routing/matchers/custom.rb

@@ -5,19 +5,22 @@ module Wayfarer
     module Matchers
       class Custom
         include Stringify
+        include EmptyParams
 
         attr_reader :delegate
 
-        def initialize(delegate = proc)
+        def initialize(delegate)
           @delegate = delegate
         end
 
-        def match(url)
-          !!delegate.call(url)
+        def evaluate(path_finder)
+          Wayfarer::Routing::RootRoute.new.tap do |route|
+            delegate.call(route, path_finder.uri, path_finder.task)
+          end
         end
 
-        def params(_)
-          {}
+        def to_h
+          { custom: delegate.class.name }
         end
       end
     end

data/lib/wayfarer/routing/matchers/{suffix.rb → empty_params.rb}

@@ -3,13 +3,9 @@
 module Wayfarer
   module Routing
     module Matchers
-      Suffix = Struct.new(:suffix) do
-        def match(url)
-          url.path.end_with?(suffix)
-        end
-
+      module EmptyParams
         def params(_)
-          {}
+          Wayfarer::Routing::Route::EMPTY_PARAMS
         end
       end
     end

data/lib/wayfarer/routing/matchers/host.rb

@@ -3,17 +3,23 @@
 module Wayfarer
   module Routing
     module Matchers
-      Host = Struct.new(:host) do
-        # rubocop:disable Style/CaseEquality
-        def match(url)
-          # url.host excludes the port
-          # TODO: Test case, docs
-          host === url.authority
+      class Host
+        include EmptyParams
+
+        attr_reader :host
+
+        def initialize(host)
+          @host = host
+        end
+
+        def evaluate(path_finder)
+          # rubocop:disable Style/CaseEquality -- String and Regexp matching
+          @host === path_finder.uri.host
+          # rubocop:enable Style/CaseEquality
         end
-        # rubocop:enable Style/CaseEquality
 
-        def params(_)
-          {}
+        def to_h
+          { name: host }
         end
       end
     end

data/lib/wayfarer/routing/matchers/path.rb

@@ -4,46 +4,24 @@ module Wayfarer
   module Routing
     module Matchers
       class Path
-        attr_reader :path,
-                    :route,
-                    :peeking,
-                    :matcher
+        PATTERN_TYPE = "sinatra"
 
-        def initialize(path, route)
-          @path = path
-          @route = route
-          @peeking = false
-          @matcher = Mustermann.new(path, type: "sinatra") # TODO: Add type constant
-        end
-
-        def match(url)
-          # TODO: Ditch this and add a parameter to the path DSL#path
-          #
-          # If the route's branch contains other path matchers in child routes,
-          # match the beginning of the path (peeking), instead of the whole path.
-          route.accept(self)
+        attr_reader :pattern
 
-          !!(if peeking
-               matcher.peek(url.path)
-             else
-               matcher.match(url.path)
-             end)
+        def initialize(pattern)
+          @pattern = Mustermann.new(pattern, type: PATTERN_TYPE)
         end
 
-        def params(url)
-          return {} unless match(url)
-
-          matcher.params(url.path) || {}
+        def evaluate(path_finder)
+          path_finder.path_consumer.current_state.valid?
         end
 
-        def visit(route)
-          return true if route == self.route
-          return true if route.is_a?(TargetRoute)
-
-          return unless route.matcher.is_a?(self.class)
+        def params(path_finder)
+          path_finder.path_consumer.current_state.params
+        end
 
-          @peeking = true
-          false
+        def to_h
+          { pattern: pattern.to_s }
         end
       end
     end

data/lib/wayfarer/routing/matchers/query.rb

@@ -3,33 +3,56 @@
 module Wayfarer
   module Routing
     module Matchers
-      Query = Struct.new(:fields) do
-        def match(url)
-          query = url.query
+      class Query
+        attr_reader :fields
+
+        def initialize(fields)
+          @fields = fields
+        end
+
+        def evaluate(path_finder)
+          query = path_finder.uri.query
 
-          # CGI::parse throws a NoMethodError if the query is an empty string
           return false if query.nil? || query.empty?
 
-          CGI.parse(query).none? { |field, vals| violates?(field, vals) }
-        end
+          # TODO: Move query parameter parsing to PathFinder
+          parsed_query = CGI.parse(query)
 
-        def params(url)
-          return {} unless match(url)
+          # For every expected field in `fields`,
+          # check that it is present and does not violate the constraint.
+          fields.all? do |(field_key, constraint)|
+            param_vals = parsed_query[field_key.to_s]
 
-          CGI.parse(url.query)
-             .select { |(k, _)| fields.keys.include?(k.to_sym) }
-             .transform_values(&:last)
+            # If the param is absent, mismatch
+            if param_vals.nil? || param_vals.empty?
+              false
+            else
+              !violates_constraint?(constraint, param_vals)
+            end
+          end
         end
 
-      private
+        def params(path_finder)
+          return {} unless evaluate(path_finder)
 
-        # rubocop:disable Lint/AssignmentInCondition
-        def violates?(field, vals)
-          return false unless constraint = fields[field.to_sym]
+          parsed_query = CGI.parse(path_finder.uri.query)
 
-          violates_constraint?(constraint, vals)
+          parsed_query
+            .select { |k, _| fields.keys.include?(k.to_sym) }
+            .transform_values(&:last)
         end
-        # rubocop:enable Lint/AssignmentInCondition
+
+        def to_h
+          fields.transform_values do |val|
+            case val
+            when Regexp then val.inspect
+            when Range then { min: val.min, max: val.max }
+            else val
+            end
+          end
+        end
+
+      private
 
         def violates_constraint?(constraint, vals)
           case constraint
@@ -37,6 +60,7 @@ module Wayfarer
           when Integer then violates_integer?(constraint, vals)
           when Regexp  then violates_regexp?(constraint, vals)
           when Range   then violates_range?(constraint, vals)
+          else false
           end
         end
 

data/lib/wayfarer/routing/matchers/result.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Wayfarer
+  module Routing
+    module Matchers
+      module Result
+        Match = Class.new.include(Singleton)
+        Mismatch = Class.new.include(Singleton)
+      end
+    end
+  end
+end

data/lib/wayfarer/routing/matchers/scheme.rb

@@ -3,13 +3,21 @@
 module Wayfarer
   module Routing
     module Matchers
-      Scheme = Struct.new(:scheme) do
-        def match(url)
-          url.scheme == scheme.to_s
+      class Scheme
+        include EmptyParams
+
+        attr_reader :scheme
+
+        def initialize(scheme)
+          @scheme = scheme
+        end
+
+        def evaluate(path_finder)
+          path_finder.uri.scheme == scheme.to_s
         end
 
-        def params(_)
-          {}
+        def to_h
+          { scheme: scheme }
         end
       end
     end

data/lib/wayfarer/routing/matchers/url.rb

@@ -3,13 +3,21 @@
 module Wayfarer
   module Routing
     module Matchers
-      URL = Struct.new(:url) do
-        def match(url)
-          url == Addressable::URI.parse(self.url)
+      class URL
+        include EmptyParams
+
+        attr_reader :url
+
+        def initialize(url)
+          @url = Addressable::URI.parse(url)
+        end
+
+        def evaluate(path_finder)
+          path_finder.uri == url
         end
 
-        def params(_)
-          {}
+        def to_h
+          { url: url.to_s }
         end
       end
     end

data/lib/wayfarer/routing/path_consumer.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module Wayfarer
+  module Routing
+    # Tracks path consumption during route matching.
+    #
+    # @api private
+    class PathConsumer
+      # The result of consuming part of a path.
+      #
+      # @!attribute offset
+      #   @return [Integer, nil] index into the path string
+      # @!attribute params
+      #   @return [Hash] collected path parameters
+      # @!attribute valid?
+      #   @return [Boolean] whether the current state is valid
+      ConsumptionState = Struct.new(:offset, :params, :valid?, keyword_init: true)
+
+      INITIAL_OFFSET = nil
+
+      # Initial valid state, before any path is consumed.
+      INITIAL_STATE = ConsumptionState.new(
+        offset: INITIAL_OFFSET,
+        params: Wayfarer::Routing::Route::EMPTY_PARAMS,
+        valid?: true
+      ).freeze
+
+      # @return [String] full path being consumed
+      attr_reader :path
+
+      def initialize(path)
+        @path = File.join(File::SEPARATOR, path)
+        @states = [INITIAL_STATE]
+      end
+
+      # Whether the path was fully consumed or not consumed at all.
+      #
+      # @return [Boolean]
+      def valid?
+        current_state.valid? && consumed?
+      end
+
+      # The most recent consumption state.
+      #
+      # @return [ConsumptionState]
+      def current_state
+        states.last
+      end
+
+      # Attempts to consume the path if the route has a {Matchers::Path}
+      # and pushes a new state as a result.
+      #
+      # @param route [Wayfarer::Routing::Route]
+      def push(route)
+        states.push(next_state(route))
+      end
+
+      # Reverts to the previous state.
+      #
+      # @return [ConsumptionState] the popped state
+      def pop
+        states.pop
+      end
+
+    private
+
+      attr_reader :states
+
+      def current_offset
+        current_state.offset || 0
+      end
+
+      def consumed?
+        nothing_consumed? || fully_consumed?
+      end
+
+      def nothing_consumed?
+        current_state.offset == INITIAL_OFFSET
+      end
+
+      def fully_consumed?
+        current_offset >= path.length || trailing_slash?
+      end
+
+      def trailing_slash?
+        current_offset + 1 == path.length && path[-1] == File::SEPARATOR
+      end
+
+      def sub_path
+        return File::SEPARATOR if (offset = current_offset) >= path.length
+
+        File.join(File::SEPARATOR, path[offset..])
+      end
+
+      def next_state(route)
+        return unchanged_state unless route.matcher.is_a?(Wayfarer::Routing::Matchers::Path)
+
+        consumed_state(route.matcher.pattern)
+      end
+
+      def consumed_state(pattern)
+        return unchanged_state unless current_state.valid?
+
+        match_data = pattern.peek_match(sub_path) or return invalid_state
+        matched_path = match_data.to_s
+
+        new_offset = current_offset + matched_path.length
+        new_params = current_state.params.merge(match_data.named_captures)
+
+        ConsumptionState.new(
+          offset: new_offset,
+          params: new_params,
+          valid?: true
+        )
+      end
+
+      def unchanged_state
+        current_state.dup
+      end
+
+      def invalid_state
+        ConsumptionState.new(
+          offset: current_offset,
+          params: current_state.params,
+          valid?: false
+        )
+      end
+    end
+  end
+end

data/lib/wayfarer/routing/path_finder.rb

@@ -2,44 +2,172 @@
 
 module Wayfarer
   module Routing
+    # Encapsulates all state needed to route a URL.
+    #
+    # @api private
     class PathFinder
-      def self.result(route, url)
-        finder = new(url)
+      include KV
+
+      # The result of traversing the route with a new {PathFinder} for `url`.
+      #
+      # @param route [Wayfarer::Routing::Route]
+      # @param task [Wayfarer::Task]
+      # @param callback [Proc]
+      # @return [Result::Match, Result::Mismatch]
+      def self.result(route, task, &)
+        accept_finder(route, new(task, &))
+      end
+
+      # The result of traversing the route with an existing {PathFinder}.
+      #
+      # @param route [Wayfarer::Routing::Route]
+      # @param path_finder [PathFinder]
+      # @return [Result::Match, Result::Mismatch]
+      def self.sub_result(route, path_finder)
+        accept_finder(route, path_finder)
+      end
+
+      # @param route [Wayfarer::Routing::Route]
+      # @param finder [PathFinder]
+      # @return [Result::Match, Result::Mismatch]
+      private_class_method def self.accept_finder(route, finder)
         route.accept(finder)
-        return Result::Mismatch.new if finder.path.none?
+        return Result::Mismatch.instance unless finder.found?
 
         Result::Match.new(finder.action, finder.params)
       end
 
-      attr_reader :url,
-                  :path,
-                  :action,
-                  :params
+      # @return [Wayfarer::Task]
+      attr_reader :task
+
+      # @return [Addressable::URI]
+      attr_reader :uri
+
+      # @return [String]
+      attr_reader :path
+
+      # @return [Wayfarer::Routing::PathConsumer]
+      attr_reader :path_consumer
+
+      # @return [Array<Wayfarer::Routing::Route>]
+      attr_reader :current_path, :found_path
+
+      # @return [Object, nil]
+      attr_reader :action
+
+      # @return [Hash]
+      attr_reader :params
+
+      # @return [Wayfarer::Routing::HashStack]
+      attr_reader :params_stack
+
+      # @param task [Wayfarer::Task]
+      # @param path_consumer [PathConsumer] internal use only
+      # @param params_stack [HashStack] internal use only
+      # @param stop_when_found [Boolean] whether traversal halts on match
+      def initialize(
+        task,
+        path_consumer: initial_path_consumer(task[:uri]),
+        params_stack: Wayfarer::Routing::HashStack.empty,
+        stop_when_found: true,
+        &callback
+      )
+        @task = task
+        @uri = task[:uri]
+        @current_path = []
+        @actions = []
+        @path_consumer = path_consumer
+        @params_stack = params_stack
+        @kv = kv
+        @callback = callback
+        @stop_when_found = stop_when_found
+        @match_history = []
+      end
+
+      # Whether a route has matched and consumed the URL.
+      #
+      # @return [Boolean]
+      def found?
+        !!found_path
+      end
+
+      # @return [Wayfarer::Routing::Route, nil]
+      def current_route
+        current_path.last
+      end
+
+      # Enters a route node, updating state.
+      #
+      # @param route [Wayfarer::Routing::Route]
+      # @return [void]
+      def enter(route)
+        return if stopped?
+
+        current_path.push(route)
+        path_consumer.push(route)
+        params_stack.push(route.params(self))
+        actions.prepend(route.action(self))
+        match_history.push(match(route))
+      end
+
+      # Leaves the current route, restoring previous state.
+      #
+      # @return [void]
+      def leave
+        return if found? && stop_when_found?
 
-      def initialize(url)
-        @url = url
-        @path = []
-        @action = nil
-        @params = {}
+        actions.pop
+        params_stack.pop
+        path_consumer.pop
+        current_path.pop
+        match_history.pop
       end
 
+      # Visits a {Route}.
+      #
+      # @param route [Wayfarer::Routing::Route]
+      # @return [Boolean] whether to continue traversal
       def visit(route)
-        return false if path.any?
-        return false unless route.match(url)
+        return false if stopped? || !match_history.last
+        return true unless route.leaf? && path_consumer.valid?
 
-        follow(route) if route.children.none?
-        true
+        found! if !found? && match_history.all?
+
+        !stop_when_found?
+      end
+
+      # Whether traversal should stop.
+      #
+      # @return [Boolean]
+      def stopped?
+        found? && stop_when_found?
       end
 
     private
 
-      # Follows the route back to the root. Collects parameters and action on
-      # the way.
-      def follow(route)
-        path.unshift(route)
-        @params.merge!(route.matcher.params(url))
-        @action = route.action unless action
-        follow(route.parent) if route.parent
+      attr_reader :actions, :callback, :match_history
+      attr_writer :found_path, :action, :params
+
+      def found!
+        self.params = params_stack.to_h
+        self.action = actions.find(&:present?)
+        self.found_path = current_path.clone.freeze
+      end
+
+      def stop_when_found?
+        !!@stop_when_found
+      end
+
+      def match(route)
+        route.match(self).tap { |result| callback&.call(route, result, self) }
+      end
+
+      def initial_path_consumer(uri)
+        Wayfarer::Routing::PathConsumer.new(url_path(uri))
+      end
+
+      def url_path(uri)
+        uri.host ? uri.path : ""
       end
     end
   end

data/lib/wayfarer/routing/result.rb

@@ -4,7 +4,7 @@ module Wayfarer
   module Routing
     module Result
       Match = Struct.new(:action, :params)
-      Mismatch = Class.new
+      Mismatch = Class.new.include(Singleton)
     end
   end
 end

data/lib/wayfarer/routing/root_route.rb

@@ -2,9 +2,21 @@
 
 module Wayfarer
   module Routing
+    # Routing tree root.
     class RootRoute < Route
-      def invoke(url)
-        PathFinder.result(self, url)
+      def initialize
+        super(parent: nil)
+      end
+
+      # @param [url] Addressable::URI
+      # @return [Result::Match, Result::Mismatch]
+      def invoke(task)
+        PathFinder.result(self, task)
+      end
+
+      # @return [true, false]
+      def evaluate(path_finder)
+        path_finder.uri.absolute? && !leaf? # Don't route URLs without routes declared
       end
     end
   end