Use structured request paths.

Assisted-By: devx/cbdeae41-9308-4071-ad53-58cd92db2946

Author: samuel-williams-shopify

lib/utopia/content/document.rb

@@ -55,7 +55,7 @@ def initialize(request, attributes = {}, localization: request&.localization)
 
 			# @returns [Path] The original request path, if known.
 			def request_path
-				Path[request.request_path]
+				request.original_path
 			end
 
 			protected def current_base_uri_path

lib/utopia/content/link.rb

@@ -6,6 +6,7 @@
 # Copyright, 2020, by Michael Adams.
 
 require "yaml"
+require "protocol/url"
 require "xrb/builder"
 
 require "xrb/strings"
@@ -51,11 +52,7 @@ def full_path(root, extension = XNODE_EXTENSION)
 			# Resolve this link's target URI.
 			# @returns [String | Nil] The explicit target URI or one derived from the content path.
 			def href
-				@href ||= @info.fetch(:uri) do
-					@info.fetch(:href) do
-						(@path.dirname + @path.basename).to_s if @path
-					end
-				end
+				target_url&.to_s
 			end
 
 			# Look up from the `links.yaml` metadata with a given symbolic key.
@@ -91,10 +88,32 @@ def virtual?
 			# @parameter base [Path | String | Nil] The source path.
 			# @returns [Path | String | Nil] The relative or unchanged target.
 			def relative_href(base = nil)
-				if base and href.start_with? "/"
-					Path.shortest_path(href, base)
-				else
-					href
+				target = target_url
+				return unless target
+				
+				case target
+				when Protocol::URL::Absolute
+					return target.to_s
+				when Protocol::URL::Relative
+					if base && target.path.absolute?
+						# Convert root-relative targets to application paths before finding the shortest path:
+						path = Path.new(target.path.components(Protocol::URL::Encoding::System))
+						relative_path = Path.shortest_path(path, base).to_url_path
+						
+						return Protocol::URL::Relative.new(relative_path, target.query, target.fragment).to_s
+					end
+				end
+				
+				return target.to_s
+			end
+			
+			private def target_url
+				if @info.key?(:uri)
+					Protocol::URL[@info[:uri]]
+				elsif @info.key?(:href)
+					Protocol::URL[@info[:href]]
+				elsif @path
+					Protocol::URL::Relative.new(@path.to_url_path)
 				end
 			end
 

lib/utopia/content/middleware.rb

@@ -123,7 +123,7 @@ def respond(link, request, localization: request.localization)
 			# @parameter request [Utopia::Request] The request.
 			# @returns [Protocol::HTTP::Response] The content, redirect, or downstream response.
 			def call(request)
-				path = Path.create(request.path_info)
+				path = request.path
 
 				# Check if the request is to a non-specific index. This only works for requests with a given name:
 				basename = path.basename
@@ -132,8 +132,9 @@ def call(request)
 				# If the request for /foo/bar is actually a directory, rewrite it to /foo/bar/index:
 				if File.directory? directory_path
 					index_path = [basename, INDEX]
+					location = path.dirname.join(index_path).to_url_path.encoded
 
-					return Utopia::Response[307, {HTTP::LOCATION => path.dirname.join(index_path).to_s}, []]
+					return Utopia::Response[307, {HTTP::LOCATION => location}, []]
 				end
 
 				response = resolve_localized(request) do |localization|

lib/utopia/controller/actions.md

@@ -32,7 +32,7 @@ on "new" do |request|
 end
 
 on "edit" do |request|
-	@user = User.find(request.query_arguments["id"])
+	@user = User.find(request.query_parameters["id"])
 
 	if request.post?
 		@user.update_attributes(parse_body(request)["user"])
@@ -42,7 +42,7 @@ on "edit" do |request|
 end
 
 on "delete" do |request|
-	User.find(request.query_arguments["id"]).destroy
+	User.find(request.query_parameters["id"]).destroy
 
 	redirect! "index"
 end

lib/utopia/controller/base.rb

@@ -4,6 +4,7 @@
 # Copyright, 2014-2025, by Samuel Williams.
 
 require_relative "../http"
+require_relative "../path"
 require_relative "../response"
 require_relative "result"
 
@@ -149,7 +150,12 @@ def ignore!
 			# Request relative redirect. Respond with a redirect to the given target.
 			def redirect!(target, status = 302)
 				status = HTTP::Status.new(status, 300...400)
-				location = target.to_s
+				
+				if target.is_a?(Utopia::Path)
+					location = target.to_url_path.encoded
+				else
+					location = target.to_s
+				end
 
 				respond! Utopia::Response[status.to_i, {HTTP::LOCATION => location}, [status.to_s]]
 			end

lib/utopia/controller/middleware.rb

@@ -86,7 +86,7 @@ def load_controller_file(uri_path)
 
 			# Invoke the controller layer for a given request. The request path may be rewritten.
 			def invoke_controllers(request)
-				request_path = Path.from_string(request.path_info)
+				request_path = request.path
 
 				# The request path must be absolute. We could handle this internally but it is probably better for this to be an error:
 				raise ArgumentError.new("Invalid request path #{request_path}") unless request_path.absolute?
@@ -114,8 +114,8 @@ def invoke_controllers(request)
 					end
 				end
 
-				# Controllers can directly modify relative_path, which is copied into controller_path. The controllers may have rewriten the path so we update the path info:
-				request.path_info = controller_path.to_s
+				# Controllers can directly modify the remaining path. Preserve those rewrites at the request boundary:
+				request.path = controller_path
 
 				# No controller gave a useful result:
 				return nil

lib/utopia/exceptions/handler.rb

@@ -44,7 +44,7 @@ def call(request)
 						# We do an internal redirection to the error location:
 						error_request = request.with(
 							method: "GET",
-							path_info: @location
+							path: @location
 						)
 						error_request.exception = exception
 

lib/utopia/exceptions/mailer.rb

@@ -79,8 +79,6 @@ def call(request)
 				:referrer,
 				:path,
 				:request_path,
-				:path_info,
-				:query,
 				:user_agent,
 			]
 
@@ -113,8 +111,8 @@ def generate_body(exception, request)
 					io.puts "request.#{key}: #{value.inspect}"
 				end
 
-				request.query_arguments.each do |key, value|
-					io.puts "request.query_arguments.#{key}: #{value.inspect}"
+				request.query_parameters.each do |key, value|
+					io.puts "request.query_parameters.#{key}: #{value.inspect}"
 				end
 
 				io.puts

lib/utopia/import_map.rb

@@ -257,7 +257,7 @@ def scope(scope_prefix, imports)
 		# Create a new import map with paths relative to the given page path.
 		# This is useful for creating page-specific import maps from a global one.
 		#
-		# @parameter path [String] The absolute page path to make imports relative to.
+		# @parameter path [String | Protocol::URL::Path] The absolute page path to make imports relative to.
 		# @returns [ImportMap] A new import map with a relative base.
 		#
 		# @example Creating page-specific import maps.
@@ -270,8 +270,8 @@ def scope(scope_prefix, imports)
 		def relative_to(path)
 			if @base
 				# Calculate the relative path from the page to the base
-				relative_base = Protocol::URL::Path.relative(@base.path, path)
-				resolved_base = Protocol::URL[relative_base]
+				relative_path = @base.path.relative(path)
+				resolved_base = Protocol::URL::Relative.new(relative_path)
 			else
 				resolved_base = nil
 			end

lib/utopia/localization/middleware.rb

@@ -92,16 +92,16 @@ def preferred_locales(request, path_locale = nil)
 				return locales.to_a
 			end
 
-			# Infer preferred locales from the request host.
+			# Infer preferred locales from the request authority.
 			# @parameter request [Utopia::Request] The application request.
-			# @yields {|locale| ...} Each locale whose host pattern matches the request host.
+			# @yields {|locale| ...} Each locale whose host pattern matches the request authority.
 			# @returns [Hash] The configured host mappings.
 			def host_preferred_locales(request)
-				http_host = request.host.to_s
+				authority = request.authority.to_s
 
-				# Yield all hosts which match the incoming http_host:
+				# Yield all hosts which match the incoming authority:
 				@hosts.each do |pattern, locale|
-					if http_host[pattern]
+					if authority[pattern]
 						yield locale
 					end
 				end
@@ -111,16 +111,34 @@ def host_preferred_locales(request)
 			# @parameter request [Utopia::Request] The application request.
 			# @returns [Array(Utopia::Request, String | Nil)] The request and extracted locale.
 			def extract_path_locale(request)
-				path = Path[request.path_info]
+				path = request.url.path
 
-				if request_locale = @all_locales.patterns[path.first]
-					# Remove the localization prefix:
-					path.delete_at(0)
-					
-					return request.with(path_info: path.to_s), request_locale
-				else
+				# Localization prefixes only apply to absolute application paths:
+				unless path.absolute?
 					return request, nil
 				end
+				
+				if segment = path.segments[1]
+					# Decode only the component which may contain the locale:
+					component = Protocol::URL::Encoding::System.unescape(segment)
+					
+					if request_locale = @all_locales.patterns[component]
+						# Remove the locale while preserving all other encoded segments:
+						segments = path.segments.dup
+						segments.delete_at(1)
+						
+						# Preserve the absolute root when the locale was the only component:
+						if segments == [""]
+							segments << ""
+						end
+						
+						path = Protocol::URL::Path.new(nil, segments)
+						
+						return request.with(path: path), request_locale
+					end
+				end
+				
+				return request, nil
 			end
 
 			# Parse the locales preferred by the browser.
@@ -147,8 +165,8 @@ def browser_preferred_locales(request)
 			# @returns [Boolean] Whether the path is eligible for localization.
 			def localized?(request)
 				# Ignore requests which match the ignored paths:
-				path_info = request.path_info
-				return false if @ignore.any?{|pattern| path_info[pattern] != nil}
+				path = request.url.path.encoded
+				return false if @ignore.any?{|pattern| path[pattern] != nil}
 
 				return true
 			end