utopia 2.30.2 → 2.31.0

data/lib/utopia/content/document.rb

@@ -8,7 +8,9 @@ require_relative "response"
 require_relative "markup"
 
 module Utopia
-	class Content
+	module Content
+		DEFERRED_TAG_NAME = "utopia:deferred".freeze
+		
 		# This error is raised if a tag doesn't match up when parsing.
 		class UnbalancedTagError < StandardError
 			def initialize(tag)
@@ -81,34 +83,34 @@ module Utopia
 			def localization
 				@localization ||= Utopia::Localization[request]
 			end
-
+			
 			def parse_markup(markup)
 				MarkupParser.parse(markup, self)
 			end
-
+			
 			# The Rack::Request for this document.
 			attr :request
-
+			
 			# Per-document global attributes.
 			attr :attributes
-
+			
 			# The current state, represents a list from outer to inner most tag by traversing {State#parent}.
 			# At any point in parsing markup, this is a list of the inner most tag,
 			# then the next outer tag, etc.
 			attr :current
-
+			
 			# The first {State} generated by rendering this document. It contains useful information
 			# regarding the node and uri used to access the resource.
 			attr :first
-
+			
 			# End tags represents a list of execution order. This is the order that end tags
 			# have appeared when evaluating nodes.
 			attr :end_tags
-
+			
 			def tag(name, attributes = {})
 				# If we provide a block which can give inner data, we are not self-closing.
 				tag = Tag.new(name, !block_given?, attributes)
-
+				
 				if block_given?
 					node = tag_begin(tag)
 					yield node
@@ -117,10 +119,10 @@ module Utopia
 					tag_complete(tag, node)
 				end
 			end
-
+			
 			def tag_complete(tag, node = nil)
 				node ||= lookup_tag(tag)
-
+				
 				if node
 					tag_begin(tag, node)
 					tag_end(tag)
@@ -128,22 +130,22 @@ module Utopia
 					@current.tag_complete(tag)
 				end
 			end
-
+			
 			def tag_begin(tag, node = nil)
 				node ||= lookup_tag(tag)
-
+				
 				if node
 					@current = State.new(@current, tag, node)
-
+					
 					node.tag_begin(self, state) if node.respond_to?(:tag_begin)
-
+					
 					return node
 				end
-
+				
 				# raise ArgumentError.new("tag_begin: #{tag} is tag.self_closed?") if tag.self_closed?
-
+				
 				@current.tag_begin(tag)
-
+				
 				return nil
 			end
 			
@@ -152,35 +154,35 @@ module Utopia
 			end
 			
 			alias cdata write
-
+			
 			def text(string)
 				@current.text(string)
 			end
-
+			
 			def tag_end(tag = nil)
 				# Determine if the current state contains tags that need to be completed, or if the state itself is finished.
 				if @current.empty?
 					if node = @current.node
 						node.tag_end(self, @current) if node.respond_to?(:tag_end)
 					end
-
+					
 					@end_tags << @current
 					buffer = @current.call(self)
-
+					
 					@current = @current.parent
 					@end_tags.pop
-
+					
 					@current.write(buffer) if @current
-
+					
 					return buffer
 				else
 					# raise ArgumentError.new("tag_begin: #{tag} is tag.self_closed?") if tag.self_closed?
 					@current.tag_end(tag)
 				end
-
+				
 				return nil
 			end
-
+			
 			def render_node(node, attributes = {})
 				@current = State.new(@current, nil, node, attributes)
 				
@@ -190,7 +192,7 @@ module Utopia
 				# This returns the content of rendering the tag:
 				return tag_end
 			end
-
+			
 			# Maps a tag to a node instance by asking the current node to lookup the tag name. This function is called for each tag and thus heavily affects performance.
 			# @return [Node] The node for the given tag.
 			def lookup_tag(tag)
@@ -223,7 +225,7 @@ module Utopia
 			def content
 				@end_tags.last.content
 			end
-
+			
 			def parent
 				@end_tags[-2]
 			end
@@ -244,7 +246,7 @@ module Utopia
 				
 				@tags = []
 			end
-
+			
 			attr :parent
 			attr :attributes
 			attr :content
@@ -252,9 +254,9 @@ module Utopia
 			
 			# A list of all tags in order of rendering them, which have not been finished yet.
 			attr :tags
-
+			
 			attr :deferred
-
+			
 			def defer(value = nil, &block)
 				@deferred << block
 				
@@ -264,7 +266,7 @@ module Utopia
 			def [](key)
 				@attributes[key]
 			end
-
+			
 			def call(document)
 				@content = @buffer
 				@buffer = XRB::MarkupString.new.force_encoding(Encoding::UTF_8)
@@ -277,15 +279,15 @@ module Utopia
 				
 				return @buffer
 			end
-
+			
 			def write(string)
 				@buffer << string
 			end
-
+			
 			def text(string)
 				XRB::Markup.append(@buffer, string)
 			end
-
+			
 			def tag_complete(tag)
 				tag.write(@buffer)
 			end
@@ -294,14 +296,14 @@ module Utopia
 			def empty?
 				@tags.empty?
 			end
-
+			
 			def tag_begin(tag)
 				# raise ArgumentError.new("tag_begin: #{tag} is tag.self_closed?") if tag.self_closed?
 				
 				@tags << tag
 				tag.write_opening_tag(@buffer)
 			end
-
+			
 			def tag_end(tag)
 				raise UnbalancedTagError.new(tag) unless @tags.pop.name == tag.name
 				tag.write_closing_tag(@buffer)

data/lib/utopia/content/link.rb

@@ -11,10 +11,9 @@ require "xrb/builder"
 require "xrb/strings"
 
 require_relative "../path"
-require_relative "../locale"
 
 module Utopia
-	class Content
+	module Content
 		# Represents a link to some content with associated metadata.
 		class Link
 			# @param kind [Symbol] the kind of link.

data/lib/utopia/content/links.rb

@@ -8,7 +8,7 @@ require_relative "link"
 require "concurrent/map"
 
 module Utopia
-	class Content
+	module Content
 		# The file extension for markup nodes on disk.
 		XNODE_EXTENSION = ".xnode"
 		INDEX = "index"
@@ -114,7 +114,7 @@ module Utopia
 			def symbolize_keys(map)
 				# Second level attributes should be symbolic:
 				map.each do |key, info|
-					map[key] = info.each_with_object({}) { |(k,v),result| result[k.to_sym] = v }
+					map[key] = info.each_with_object({}){|(k,v),result| result[k.to_sym] = v}
 				end
 				
 				return map

data/lib/utopia/content/markup.rb

@@ -9,7 +9,7 @@ require "xrb/strings"
 require "xrb/tag"
 
 module Utopia
-	class Content
+	module Content
 		Tag = XRB::Tag
 		
 		# A hash which forces all keys to be symbols and fails with KeyError when strings are used.
@@ -60,7 +60,7 @@ module Utopia
 					@opening_tag = opening_tag
 					@closing_tag = closing_tag
 				end
-
+				
 				attr :buffer
 				attr :opening_tag
 				attr :closing_tag
@@ -108,15 +108,15 @@ module Utopia
 					raise UnbalancedTagError.new(@buffer, tag)
 				end
 			end
-
+			
 			def open_tag_begin(name, offset)
 				@current = ParsedTag.new(name, offset)
 			end
-
+			
 			def attribute(key, value)
 				@current.tag.attributes[key] = value
 			end
-
+			
 			def open_tag_end(self_closing)
 				if self_closing
 					@current.tag.closed = true
@@ -128,7 +128,7 @@ module Utopia
 				
 				@current = nil
 			end
-
+			
 			def close_tag(name, offset)
 				@current = @stack.pop
 				tag = @current.tag
@@ -143,19 +143,19 @@ module Utopia
 			def doctype(string)
 				@delegate.write(string)
 			end
-
+			
 			def comment(string)
 				@delegate.write(string)
 			end
-
+			
 			def instruction(string)
 				@delegate.write(string)
 			end
-
+			
 			def cdata(string)
 				@delegate.write(string[9..-4])
 			end
-
+			
 			def text(string)
 				@delegate.text(string)
 			end

data/lib/utopia/content/middleware.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2009-2025, by Samuel Williams.
+
+require_relative "../middleware"
+require_relative "../localization"
+
+require_relative "links"
+require_relative "node"
+require_relative "markup"
+require_relative "tags"
+
+require "xrb/template"
+require "concurrent/map"
+require "traces/provider"
+
+module Utopia
+	module Content
+		# A middleware which serves dynamically generated content based on markup files.
+		class Middleware
+			CONTENT_NAMESPACE = "content".freeze
+			UTOPIA_NAMESPACE = "utopia".freeze
+			CONTENT_TAG_NAME = "utopia:content".freeze
+			
+			# @param root [String] The content root where pages will be generated from.
+			# @param namespaces [Hash<String,Library>] Tag namespaces for dynamic tag lookup.
+			def initialize(app, root: Utopia::default_root, namespaces: {})
+				@app = app
+				@root = root
+				
+				@template_cache = Concurrent::Map.new
+				@node_cache = Concurrent::Map.new
+				
+				@links = Links.new(@root)
+				
+				@namespaces = namespaces
+				
+				# Default content namespace for dynamic path based lookup:
+				@namespaces[CONTENT_NAMESPACE] ||= self.method(:content_tag)
+				
+				# The core namespace for utopia specific functionality:
+				@namespaces[UTOPIA_NAMESPACE] ||= Tags
+			end
+			
+			def freeze
+				return self if frozen?
+				
+				@root.freeze
+				@namespaces.values.each(&:freeze)
+				@namespaces.freeze
+				
+				super
+			end
+			
+			attr :root
+			
+			# TODO we should remove this method and expose `@links` directly.
+			def links(path, **options)
+				@links.index(path, **options)
+			end
+			
+			def fetch_template(path)
+				@template_cache.fetch_or_store(path.to_s) do
+					XRB::Template.load_file(path)
+				end
+			end
+			
+			# Look up a named tag such as `<entry />` or `<content:page>...`
+			def lookup_tag(qualified_name, node)
+				namespace, name = XRB::Tag.split(qualified_name)
+				
+				if library = @namespaces[namespace]
+					library.call(name, node)
+				end
+			end
+			
+			# @param path [Path] the request path is an absolute uri path, e.g. `/foo/bar`. If an xnode file exists on disk for this exact path, it is instantiated, otherwise nil.
+			def lookup_node(path, locale = nil)
+				resolve_link(
+					@links.for(path, locale)
+				)
+			end
+			
+			def resolve_link(link)
+				if full_path = link&.full_path(@root)
+					if File.exist?(full_path)
+						return Node.new(self, link.path, link.path, full_path)
+					end
+				end
+			end
+			
+			def respond(link, request)
+				if node = resolve_link(link)
+					attributes = request.env.fetch(VARIABLES_KEY, {}).to_hash
+					
+					return node.process!(request, attributes)
+				elsif redirect_uri = link[:uri]
+					return [307, {HTTP::LOCATION => redirect_uri}, []]
+				end
+			end
+			
+			def call(env)
+				request = Rack::Request.new(env)
+				path = Path.create(request.path_info)
+				
+				# Check if the request is to a non-specific index. This only works for requests with a given name:
+				basename = path.basename
+				directory_path = File.join(@root, path.dirname.components, basename)
+				
+				# 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]
+					
+					return [307, {HTTP::LOCATION => path.dirname.join(index_path).to_s}, []]
+				end
+				
+				locale = env[Localization::CURRENT_LOCALE_KEY]
+				if link = @links.for(path, locale)
+					if response = self.respond(link, request)
+						return response
+					end
+				end
+				
+				return @app.call(env)
+			end
+			
+			private
+			
+			def lookup_content(name, parent_path)
+				if String === name && name.index("/")
+					name = Path.create(name)
+				end
+				
+				if Path === name
+					name = parent_path + name
+					name_path = name.components.dup
+					name_path[-1] += XNODE_EXTENSION
+				else
+					name_path = name + XNODE_EXTENSION
+				end
+				
+				components = parent_path.components.dup
+				
+				while components.any?
+					tag_path = File.join(@root, components, name_path)
+					
+					if File.exist? tag_path
+						return Node.new(self, Path[components] + name, parent_path + name, tag_path)
+					end
+					
+					if String === name_path
+						tag_path = File.join(@root, components, "_" + name_path)
+						
+						if File.exist? tag_path
+							return Node.new(self, Path[components] + name, parent_path + name, tag_path)
+						end
+					end
+					
+					components.pop
+				end
+				
+				return nil
+			end
+			
+			def content_tag(name, node)
+				full_path = node.parent_path + name
+				
+				name = full_path.pop
+				
+				# If the current node is called 'foo', we can't lookup 'foo' in the current directory or we will have infinite recursion.
+				while full_path.last == name
+					full_path.pop
+				end
+				
+				cache_key = full_path + name
+				
+				@node_cache.fetch_or_store(cache_key) do
+					lookup_content(name, full_path)
+				end
+			end
+		end
+		
+		Traces::Provider(Middleware) do
+			def respond(link, request)
+				attributes = {
+					"link.key" => link.key,
+					"link.href" => link.href
+				}
+				
+				Traces.trace("utopia.content.middleware.respond", attributes: attributes) {super}
+			end
+		end
+	end
+end

data/lib/utopia/content/namespace.rb

@@ -4,7 +4,7 @@
 # Copyright, 2017-2022, by Samuel Williams.
 
 module Utopia
-	class Content
+	module Content
 		# A namespace which contains tags which can be rendered within a {Document}.
 		module Namespace
 			def self.extended(other)

data/lib/utopia/content/node.rb

@@ -12,7 +12,7 @@ require_relative "document"
 require "pathname"
 
 module Utopia
-	class Content
+	module Content
 		# Represents an immutable node within the content hierarchy.
 		class Node
 			def initialize(controller, uri_path, request_path, file_path)

data/lib/utopia/content/response.rb

@@ -4,7 +4,7 @@
 # Copyright, 2010-2025, by Samuel Williams.
 
 module Utopia
-	class Content
+	module Content
 		# Compatibility with older versions of rack:
 		EXPIRES = "expires".freeze
 		CACHE_CONTROL = "cache-control".freeze

data/lib/utopia/content/tags.rb

@@ -8,7 +8,7 @@ require_relative "namespace"
 require "variant"
 
 module Utopia
-	class Content
+	module Content
 		# Tags which provide intrinsic behaviour within the content middleware.
 		module Tags
 			extend Namespace