utopia 2.13.4 → 2.16.1

data/lib/utopia/content/markup.rb

@@ -40,7 +40,7 @@ module Utopia
 				super key.to_sym, value
 			end
 			
-			def fetch(key, *args, &block)
+			def fetch(key, *arguments, &block)
 				key = key.to_sym
 				
 				super

data/lib/utopia/content/node.rb

@@ -33,28 +33,24 @@ module Utopia
 		class Node
 			def initialize(controller, uri_path, request_path, file_path)
 				@controller = controller
-
+				
 				@uri_path = uri_path
 				@request_path = request_path
 				@file_path = file_path
 			end
-
+			
 			attr :request_path
 			attr :uri_path
 			attr :file_path
-
+			
 			def name
 				@uri_path.basename
 			end
-
-			def link
-				return Link.new(:file, uri_path)
-			end
-
+			
 			def lookup_node(path)
 				@controller.lookup_node(parent_path + Path[path])
 			end
-
+			
 			def local_path(path = '.', base = nil)
 				path = Path[path]
 				
@@ -78,7 +74,7 @@ module Utopia
 			def parent_path
 				@uri_path.dirname
 			end
-
+			
 			def links(path = '.', **options, &block)
 				path = uri_path.dirname + Path[path]
 				
@@ -90,11 +86,11 @@ module Utopia
 					links
 				end
 			end
-
+			
 			def related_links
-				@controller.links(@uri_path.dirname, :name => @uri_path.basename, :indices => true)
+				@controller.links(@uri_path.dirname, name: @uri_path.basename, indices: true)
 			end
-
+			
 			def siblings_path
 				if @uri_path.basename == INDEX
 					@uri_path.dirname(2)
@@ -102,7 +98,7 @@ module Utopia
 					@uri_path.dirname
 				end
 			end
-
+			
 			def sibling_links(**options)
 				return @controller.links(siblings_path, **options)
 			end
@@ -129,15 +125,15 @@ module Utopia
 			def process!(request, attributes = {})
 				Document.render(self, request, attributes).to_a
 			end
-		
+			
 			# This is a special context in which a limited set of well defined methods are exposed in the content view.
 			Context = Struct.new(:document, :state) do
-				def partial(*args, &block)
+				def partial(*arguments, &block)
 					if block_given?
 						state.defer(&block)
 					else
 						state.defer do |document|
-							document.tag(*args)
+							document.tag(*arguments)
 						end
 					end
 				end
@@ -173,11 +169,11 @@ module Utopia
 				def content
 					document.content
 				end
-
+				
 				def parent
 					document.parent
 				end
-
+				
 				def first
 					document.first
 				end

data/lib/utopia/content/response.rb

@@ -23,9 +23,9 @@
 module Utopia
 	class Content
 		# Compatibility with older versions of rack:
-		EXPIRES = 'Expires'.freeze
-		CACHE_CONTROL = 'Cache-Control'.freeze
-		CONTENT_TYPE = 'Content-Type'.freeze
+		EXPIRES = 'expires'.freeze
+		CACHE_CONTROL = 'cache-control'.freeze
+		CONTENT_TYPE = 'content-type'.freeze
 		NO_CACHE = 'no-cache'.freeze
 		
 		# A basic content response, including useful defaults for typical HTML5 content.
@@ -39,7 +39,7 @@ module Utopia
 				self.content_type = "text/html; charset=utf-8"
 			end
 			
-			attr :status
+			attr_accessor :status
 			attr :headers
 			attr :body
 			
@@ -68,7 +68,7 @@ module Utopia
 					@headers[EXPIRES] = (Time.now + duration).httpdate
 				end
 			end
-
+			
 			# Specify the content type of the response data.
 			def content_type= value
 				@headers[CONTENT_TYPE] = value

data/lib/utopia/controller.rb

@@ -33,20 +33,6 @@ require_relative 'controller/actions'
 require 'concurrent/map'
 
 module Utopia
-	# A container for controller classes which are loaded from disk.
-	module Controllers
-		def self.class_name_for_controller(controller)
-			controller.uri_path.to_a.collect{|_| _.capitalize}.join + "_#{controller.object_id}"
-		end
-		
-		def self.define(klass)
-			self.const_set(
-				class_name_for_controller(klass),
-				klass,
-			)
-		end
-	end
-	
 	# A middleware which loads controller classes and invokes functionality based on the requested path.
 	class Controller
 		# The controller filename.
@@ -105,9 +91,6 @@ module Utopia
 				
 				klass.class_eval(File.read(controller_path), controller_path)
 				
-				# Give the controller a useful name:
-				# Controllers.define(klass)
-				
 				# We lock down the controller class to prevent unsafe modifications:
 				klass.freeze
 				

data/lib/utopia/controller/base.rb

@@ -24,8 +24,14 @@ require_relative '../http'
 
 module Utopia
 	class Controller
+		CONTENT_TYPE = HTTP::CONTENT_TYPE
+		
 		# The base implementation of a controller class.
 		class Base
+			URI_PATH = nil
+			BASE_PATH = nil
+			CONTROLLER = nil
+			
 			# A string which is the full path to the directory which contains the controller.
 			def self.base_path
 				self.const_get(:BASE_PATH)
@@ -41,6 +47,24 @@ module Utopia
 				self.const_get(:CONTROLLER)
 			end
 			
+			def self.inspect
+				"#{super}#{self.uri_path}"
+			end
+			
+			def self.to_s
+				self.inspect
+			end
+			
+			def to_s
+				"\#<#{self.class}>"
+			end
+			
+			def inspect
+				details = self.instance_variables.map{|name| " #{name}=#{self.instance_variable_get(name)}"}
+				
+				"\#<#{self.class}#{details.join}>"
+			end
+			
 			class << self
 				def freeze
 					# This ensures that all class variables are frozen.
@@ -116,11 +140,11 @@ module Utopia
 			end
 			
 			# Succeed the request and immediately respond.
-			def succeed!(status: 200, headers: {}, **options)
+			def succeed!(status: 200, headers: {}, type: nil, **options)
 				status = HTTP::Status.new(status, 200...300)
 				
-				if options[:type]
-					headers[Rack::CONTENT_TYPE] = options[:type].to_s
+				if type
+					headers[CONTENT_TYPE] = type.to_s
 				end
 				
 				body = body_for(status, headers, options)

data/lib/utopia/controller/respond.rb

@@ -21,7 +21,7 @@
 # THE SOFTWARE.
 
 require_relative '../http'
-require_relative '../path/matcher'
+require_relative '../responder'
 
 module Utopia
 	class Controller
@@ -31,139 +31,82 @@ module Utopia
 				base.extend(ClassMethods)
 			end
 			
-			module Converter
-				def self.update_response(response, updated_headers)
-					status, headers, body = response
+			module Handlers
+				module JSON
+					APPLICATION_JSON = HTTP::Accept::ContentType.new('application', 'json').freeze
 					
-					# Generate a new body:
-					body = body.collect{|content| yield content}
-					
-					# Update the headers with the requested content type:
-					headers = headers.merge(updated_headers)
-					
-					return [status, headers, body]
-				end
-				
-				Callback = Struct.new(:content_type, :block) do
-					def headers
-						{HTTP::CONTENT_TYPE => self.content_type}
+					def self.split(*arguments)
+						APPLICATION_JSON.split(*arguments)
 					end
 					
-					def split(*args)
-						self.content_type.split(*args)
-					end
-					
-					def call(context, response, media_range)
-						Converter.update_response(response, headers) do |content|
-							context.instance_exec(content, media_range, &block)
+					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
 				
-				def self.new(*args)
-					Callback.new(*args)
-				end
-				
-				# To accept incoming requests with content-type JSON (e.g. POST with JSON data), consider using `Rack::PostBodyContentTypeParser`.
-				module ToJSON
-					APPLICATION_JSON = HTTP::Accept::ContentType.new('application', 'json', charset: 'utf-8').freeze
-					HEADERS = {HTTP::CONTENT_TYPE => APPLICATION_JSON.to_s}.freeze
+				module Passthrough
+					WILDCARD = HTTP::Accept::MediaTypes::MediaRange.new('*', '*').freeze
 					
-					def self.content_type
-						APPLICATION_JSON
+					def self.split(*arguments)
+						WILDCARD.split(*arguments)
 					end
 					
-					def self.split(*args)
-						self.content_type.split(*args)
-					end
-					
-					def self.serialize(content, media_range)
-						options = {}
-						
-						if version = media_range.parameters['version']
-							options[:version] = version.to_s
-						end
-						
-						return content.to_json(options)
-					end
-					
-					def self.call(context, response, media_range)
-						Converter.update_response(response, HEADERS) do |content|
-							self.serialize(content, media_range)
-						end
+					def self.call(context, request, media_range, object, **options)
+						# Do nothing.
 					end
 				end
 			end
 			
-			module Passthrough
-				WILDCARD = HTTP::Accept::MediaTypes::MediaRange.new('*', '*').freeze
-				
-				def self.split(*args)
-					self.media_range.split(*args)
+			class Responder < Utopia::Responder
+				def with_json
+					@handlers << Handlers::JSON
 				end
 				
-				def self.media_range
-					WILDCARD
+				def with_passthrough
+					@handlers << Handlers::Passthrough
 				end
 				
-				def self.call(context, response, media_range)
-					return nil
+				def with(content_type, &block)
+					handle(content_type, &block)
 				end
 			end
 			
-			class Responder
-				HTTP_ACCEPT = 'HTTP_ACCEPT'.freeze
-				NOT_ACCEPTABLE_RESPONSE = [406, {}, []].freeze
-				
-				def initialize
-					@converters = HTTP::Accept::MediaTypes::Map.new
+			module ClassMethods
+				def responds
+					@responder ||= Responder.new
 				end
 				
-				def freeze
-					@converters.freeze
-					
-					super
-				end
+				alias respond responds
 				
-				# Add a converter for the specified content type. Call the block with the response content if the request accepts the specified content_type.
-				def with(content_type, &block)
-					@converters << Converter::Callback.new(content_type, block)
+				def respond_to(context, request)
+					@responder&.respond_to(context, request)
 				end
 				
-				def with_passthrough
-					@converters << Passthrough
-				end
-				
-				# Add a converter for JSON when requests accept 'application/json'
-				def with_json
-					@converters << Converter::ToJSON
-				end
-				
-				def call(context, request, path, response)
-					# Parse the list of browser preferred content types and return ordered by priority:
-					media_types = HTTP::Accept::MediaTypes.browser_preferred_media_types(request.env)
-					
-					converter, media_range = @converters.for(media_types)
-					
-					if converter
-						converter.call(context, response, media_range)
-					else
-						NOT_ACCEPTABLE_RESPONSE
-					end
+				def response_for(context, request, response)
+					@responder&.respond_to(context, request).with(*response[2])
 				end
 			end
 			
-			module ClassMethods
-				def respond
-					@responder ||= Responder.new
+			def respond_to(request)
+				self.class.respond_to(self, request)
+			end
+			
+			def response_for(request, original_response)
+				response = catch(:response) do
+					self.class.response_for(self, request, original_response)
+					
+					# If the above code did not throw a new response, we return the original:
+					return original_response
 				end
 				
-				def response_for(context, request, path, response)
-					if @responder
-						@responder.call(context, request, path, response)
-					else
-						response
-					end
+				# If the user called {Base#ignore!}, it's possible response is nil:
+				if response
+					# There was an updated response so merge it:
+					return [original_response[0], original_response[1].merge(response[1]), response[2] || original_response[2]]
 				end
 			end
 			
@@ -173,11 +116,11 @@ module Utopia
 					headers = response[1]
 					
 					# Don't try to convert the response if a content type was explicitly specified.
-					unless headers[Rack::CONTENT_TYPE]
-						response = self.class.response_for(self, request, path, response)
+					if headers[HTTP::CONTENT_TYPE]
+						return response
+					else
+						return self.response_for(request, response)
 					end
-					
-					response
 				end
 			end
 		end

data/lib/utopia/extensions/array_split.rb

@@ -23,8 +23,8 @@
 module Utopia
 	module Extensions
 		module ArraySplit
-			def split_at(*args, &block)
-				if middle = index(*args, &block)
+			def split_at(*arguments, &block)
+				if middle = index(*arguments, &block)
 					[self[0...middle], self[middle], self[middle+1..-1]]
 				else
 					[[], nil, []]

data/lib/utopia/http.rb

@@ -90,9 +90,9 @@ module Utopia
 			503 => 'Service Unavailable'.freeze
 		}.merge(Rack::Utils::HTTP_STATUS_CODES)
 		
-		CONTENT_TYPE = 'Content-Type'.freeze
-		LOCATION = 'Location'.freeze
-		CACHE_CONTROL = 'Cache-Control'.freeze
+		CONTENT_TYPE = 'content-type'.freeze
+		LOCATION = 'location'.freeze
+		CACHE_CONTROL = 'cache-control'.freeze
 		
 		# A small HTTP status wrapper that verifies the status code within a given range.
 		class Status