utopia 2.30.2 → 2.31.0

data/lib/utopia/content.rb

@@ -3,194 +3,12 @@
 # Released under the MIT License.
 # Copyright, 2009-2025, by Samuel Williams.
 
-require_relative "middleware"
-require_relative "localization"
-
-require_relative "content/links"
-require_relative "content/node"
-require_relative "content/markup"
-require_relative "content/tags"
-
-require "xrb/template"
-
-require "concurrent/map"
-
-require "traces/provider"
+require_relative "content/middleware"
 
 module Utopia
-	# A middleware which serves dynamically generated content based on markup files.
-	class Content
-		CONTENT_NAMESPACE = "content".freeze
-		UTOPIA_NAMESPACE = "utopia".freeze
-		DEFERRED_TAG_NAME = "utopia:deferred".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(Content) do
-		def respond(link, request)
-			attributes = {
-				"link.key" => link.key,
-				"link.href" => link.href
-			}
-			
-			Traces.trace("utopia.content.respond", attributes: attributes) {super}
+	module Content
+		def self.new(...)
+			Middleware.new(...)
 		end
 	end
 end

data/lib/utopia/controller/actions.md

@@ -17,32 +17,32 @@ A simple CRUD controller might look like:
 ```ruby
 prepend Actions
 
-on 'index' do
+on "index" do
 	@users = User.all
 end
 
-on 'new' do |request|
+on "new" do |request|
 	@user = User.new
 	
 	if request.post?
-		@user.update_attributes(request.params['user'])
+		@user.update_attributes(request.params["user"])
 		
 		redirect! "index"
 	end
 end
 
-on 'edit' do |request|
-	@user = User.find(request.params['id'])
+on "edit" do |request|
+	@user = User.find(request.params["id"])
 	
 	if request.post?
-		@user.update_attributes(request.params['user'])
+		@user.update_attributes(request.params["user"])
 		
 		redirect! "index"
 	end
 end
 
-on 'delete' do |request|
-	User.find(request.params['id']).destroy
+on "delete" do |request|
+	User.find(request.params["id"]).destroy
 	
 	redirect! "index"
 end

data/lib/utopia/controller/actions.rb

@@ -6,7 +6,7 @@
 require_relative "../http"
 
 module Utopia
-	class Controller
+	module Controller
 		# A controller layer which invokes functinality based on the request path.
 		# @example
 		# 	on '*' do |request, path|

data/lib/utopia/controller/base.rb

@@ -6,7 +6,7 @@
 require_relative "../http"
 
 module Utopia
-	class Controller
+	module Controller
 		CONTENT_TYPE = HTTP::CONTENT_TYPE
 		
 		# The base implementation of a controller class.
@@ -71,14 +71,14 @@ module Utopia
 			def process!(request, relative_path)
 				return nil
 			end
-
+			
 			# Copy the instance variables from the previous controller to the next controller (usually only a few). This allows controllers to share effectively the same instance variables while still being separate classes/instances.
 			def copy_instance_variables(from)
 				from.instance_variables.each do |name|
 					self.instance_variable_set(name, from.instance_variable_get(name))
 				end
 			end
-
+			
 			# Call into the next app as defined by rack.
 			def call(env)
 				self.class.controller.app.call(env)
@@ -98,7 +98,7 @@ module Utopia
 			def ignore!
 				throw :response, nil
 			end
-
+			
 			# Request relative redirect. Respond with a redirect to the given target.
 			def redirect!(target, status = 302)
 				status = HTTP::Status.new(status, 300...400)

data/lib/utopia/controller/middleware.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2009-2025, by Samuel Williams.
+
+require_relative "../path"
+require_relative "../middleware"
+
+require_relative "variables"
+require_relative "base"
+require_relative "rewrite"
+require_relative "respond"
+require_relative "actions"
+
+require "concurrent/map"
+
+module Utopia
+	# A middleware which loads controller classes and invokes functionality based on the requested path.
+	module Controller
+		class Middleware
+			# The controller filename.
+			CONTROLLER_RB = "controller.rb".freeze
+			
+			# @param root [String] The content root where controllers will be loaded from.
+			# @param base [Class] The base class for controllers.
+			def initialize(app, root: Utopia::default_root, base: Controller::Base)
+				@app = app
+				@root = root
+				
+				@controller_cache = Concurrent::Map.new
+				
+				@base = base
+			end
+			
+			attr :app
+			
+			def freeze
+				return self if frozen?
+				
+				@root.freeze
+				@base.freeze
+				
+				super
+			end
+			
+			# Fetch the controller for the given relative path. May be cached.
+			def lookup_controller(path)
+				@controller_cache.fetch_or_store(path.to_s) do
+					load_controller_file(path)
+				end
+			end
+			
+			# Loads the controller file for the given relative url_path.
+			def load_controller_file(uri_path)
+				base_path = File.join(@root, uri_path.components)
+				
+				controller_path = File.join(base_path, CONTROLLER_RB)
+				# puts "load_controller_file(#{path.inspect}) => #{controller_path}"
+				
+				if File.exist?(controller_path)
+					klass = Class.new(@base)
+					
+					# base_path is expected to be a string representing a filesystem path:
+					klass.const_set(:BASE_PATH, base_path.freeze)
+					
+					# uri_path is expected to be an instance of Path:
+					klass.const_set(:URI_PATH, uri_path.dup.freeze)
+					
+					klass.const_set(:CONTROLLER, self)
+					
+					klass.class_eval(File.read(controller_path), controller_path)
+					
+					# We lock down the controller class to prevent unsafe modifications:
+					klass.freeze
+					
+					# Create an instance of the controller:
+					return klass.new
+				else
+					return nil
+				end
+			end
+			
+			# 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)
+				
+				# 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?
+				
+				# The controller path contains the current complete path being evaluated:
+				controller_path = Path.new
+				
+				# Controller instance variables which eventually get processed by the view:
+				variables = request.env[VARIABLES_KEY]
+				
+				while request_path.components.any?
+					# We copy one path component from the relative path to the controller path at a time. The controller, when invoked, can modify the relative path (by assigning to relative_path.components). This allows for controller-relative rewrites, but only the remaining path postfix can be modified.
+					controller_path.components << request_path.components.shift
+					
+					if controller = lookup_controller(controller_path)
+						# Don't modify the original controller:
+						controller = controller.clone
+						
+						# Append the controller to the set of controller variables, updates the controller with all current instance variables.
+						variables << controller
+						
+						if result = controller.process!(request, request_path)
+							return result
+						end
+					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.env[Rack::PATH_INFO] = controller_path.to_s
+				
+				# No controller gave a useful result:
+				return nil
+			end
+			
+			def call(env)
+				env[VARIABLES_KEY] ||= Variables.new
+				
+				request = Rack::Request.new(env)
+				
+				if result = invoke_controllers(request)
+					return result
+				end
+				
+				return @app.call(env)
+			end
+		end
+	end
+end

data/lib/utopia/controller/respond.rb

@@ -4,60 +4,16 @@
 # Copyright, 2016-2025, by Samuel Williams.
 
 require_relative "../http"
-require_relative "../responder"
+require_relative "responder"
 
 module Utopia
-	class Controller
+	module Controller
 		# A controller layer which provides a convenient way to respond to different requested content types. The order in which you add converters matters, as it determines how the incoming Accept: header is mapped, e.g. the first converter is also defined as matching the media range */*.
 		module Respond
 			def self.prepended(base)
 				base.extend(ClassMethods)
 			end
 			
-			module Handlers
-				module JSON
-					APPLICATION_JSON = HTTP::Accept::ContentType.new("application", "json").freeze
-					
-					def self.split(*arguments)
-						APPLICATION_JSON.split(*arguments)
-					end
-					
-					def self.call(context, request, media_range, object, **options)
-						if version = media_range.parameters["version"]
-							options[:version] = version.to_s
-						end
-						
-						context.succeed! content: object.to_json(options), type: APPLICATION_JSON
-					end
-				end
-				
-				module Passthrough
-					WILDCARD = HTTP::Accept::MediaTypes::MediaRange.new("*", "*").freeze
-					
-					def self.split(*arguments)
-						WILDCARD.split(*arguments)
-					end
-					
-					def self.call(context, request, media_range, object, **options)
-						# Do nothing.
-					end
-				end
-			end
-			
-			class Responder < Utopia::Responder
-				def with_json
-					@handlers << Handlers::JSON
-				end
-				
-				def with_passthrough
-					@handlers << Handlers::Passthrough
-				end
-				
-				def with(content_type, &block)
-					handle(content_type, &block)
-				end
-			end
-			
 			module ClassMethods
 				def responds
 					@responder ||= Responder.new

data/lib/utopia/controller/responder.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2020-2025, by Samuel Williams.
+
+require_relative "middleware"
+
+module Utopia
+	module Controller
+		module Handlers
+			module JSON
+				APPLICATION_JSON = HTTP::Accept::ContentType.new("application", "json").freeze
+				
+				def self.split(*arguments)
+					APPLICATION_JSON.split(*arguments)
+				end
+				
+				def self.call(context, request, media_range, object, **options)
+					if version = media_range.parameters["version"]
+						options[:version] = version.to_s
+					end
+					
+					context.succeed! content: object.to_json(options), type: APPLICATION_JSON
+				end
+			end
+			
+			module Passthrough
+				WILDCARD = HTTP::Accept::MediaTypes::MediaRange.new("*", "*").freeze
+				
+				def self.split(*arguments)
+					WILDCARD.split(*arguments)
+				end
+				
+				def self.call(context, request, media_range, object, **options)
+					# Do nothing.
+				end
+			end
+		end
+		
+		class Responder
+			Handler = Struct.new(:content_type, :block) do
+				def split(*arguments)
+					self.content_type.split(*arguments)
+				end
+				
+				def call(context, request, media_range, *arguments, **options)
+					context.instance_exec(media_range, *arguments, **options, &self.block)
+				end
+			end
+			
+			Responds = Struct.new(:responder, :context, :request) do
+				# @todo Refactor `object` -> `*arguments`...
+				def with(object, **options)
+					responder.call(context, request, object, **options)
+				end
+			end
+			
+			def initialize
+				@handlers = HTTP::Accept::MediaTypes::Map.new
+			end
+			
+			attr :handlers
+			
+			def freeze
+				@handlers.freeze
+				
+				super
+			end
+			
+			def call(context, request, *arguments, **options)
+				# Parse the list of browser preferred content types and return ordered by priority:
+				media_types = HTTP::Accept::MediaTypes.browser_preferred_media_types(request.env)
+				
+				handler, media_range = @handlers.for(media_types)
+				
+				if handler
+					handler.call(context, request, media_range, *arguments, **options)
+				end
+			end
+			
+			# Add a converter for the specified content type. Call the block with the response content if the request accepts the specified content_type.
+			def handle(content_type, &block)
+				@handlers << Handler.new(content_type, block)
+			end
+			
+			def respond_to(context, request)
+				Responds.new(self, context, request)
+			end
+			
+			def with_json
+				@handlers << Handlers::JSON
+			end
+			
+			def with_passthrough
+				@handlers << Handlers::Passthrough
+			end
+			
+			def with(content_type, &block)
+				handle(content_type, &block)
+			end
+		end
+	end
+end

data/lib/utopia/controller/rewrite.md

@@ -19,14 +19,14 @@ rewrite.extract_prefix permalink: /(?<id>\d+)-(?<title>.*)/ do |request, path, m
 	end
 end
 
-on 'post' do
+on "post" do
 	# You can do further processing here.
 	fail! unless @post.published?
 	
 	@comments = @post.comments.first(5)
 end
 
-on 'edit' do
+on "edit" do
 	# You can do further processing here.
 	fail! unless @current_user&.editor?
 end

data/lib/utopia/controller/rewrite.rb

@@ -7,7 +7,7 @@ require_relative "../http"
 require_relative "../path/matcher"
 
 module Utopia
-	class Controller
+	module Controller
 		# This controller layer rewrites the path before executing controller actions. When the rule matches, the supplied block is executed.
 		# @example
 		# 	prepend Rewrite

data/lib/utopia/controller/variables.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2014-2022, by Samuel Williams.
+# Copyright, 2014-2025, by Samuel Williams.
+
+require_relative "../middleware"
 
 module Utopia
-	class Controller
+	module Controller
 		# Provides a stack-based instance variable lookup mechanism. It can flatten a stack of controllers into a single hash.
 		class Variables
 			def initialize
@@ -14,7 +16,7 @@ module Utopia
 			def top
 				@controllers.last
 			end
-
+			
 			def << controller
 				if top = self.top
 					# This ensures that most variables will be at the top and controllers can naturally interactive with instance variables:
@@ -42,7 +44,7 @@ module Utopia
 					raise KeyError.new(key)
 				end
 			end
-
+			
 			def to_hash
 				attributes = {}
 				
@@ -56,10 +58,14 @@ module Utopia
 				
 				return attributes
 			end
-
+			
 			def [] key
 				fetch("@#{key}".to_sym, nil)
 			end
 		end
+		
+		def self.[] request
+			request.env[VARIABLES_KEY]
+		end
 	end
 end