utopia 2.15.0 → 2.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 781b8c12d30cc2ac8382cf8c6b80c752e22c371a999681c11eb94ec49352b9f7
-  data.tar.gz: 7895e057ff1f2e8247e2a52ffbc815e571cdf138028af9f5763be059cce7bd8b
+  metadata.gz: 5549c06603672129f49f5d8c7f00b9cc706786460ba6597c3459be007d508c5c
+  data.tar.gz: 7ee6b130a7a671944ec64c7a98cc8b01e7f579e64e978e3733462c2f60ead135
 SHA512:
-  metadata.gz: fbea9d1b4b9872471cd176337769d0dfcac29e85bccf53d44ec9b69998c76d6d78b6746fe590149e18092400de8c9c9f8a0efb8699e880976f13dfc7cd9489a8
-  data.tar.gz: 730f39dfca4b31f477b43e191b651fa31f16f89371599d12f9850c7732695f68a5e949f61a51785baa5d58d33285f909d072b14df03b436b7582d182e8c0c1ce
+  metadata.gz: ae1d066e702f89c544236458d8753bcc01ab07aade2eb9b7e89755d88d9ddce520e3f1453ee9c8535f5f2788ae1cd5f5d34d412b4fdd8ee0ef00008d476debfc
+  data.tar.gz: bba30364281ce80ff9c25597c7181a903579fe6fe28cf128e53ab730c768a216a3632e999a3c1f7a4ee249debe43c3e4afcfe59e1b4fee2a3f1df6c9f04f3f0e

data/bake/utopia/{yarn.rb → node.rb}

@@ -6,18 +6,18 @@ def update
 	require 'utopia/path'
 	
 	root = Pathname.new(context.root)
-	yarn_package_root = root + "node_modules"
+	package_root = root + "node_modules"
 	
 	# This is a legacy path:
-	unless yarn_package_root.directory?
-		yarn_package_root = root + "lib/components"
+	unless package_root.directory?
+		package_root = root + "lib/components"
 	end
 	
-	yarn_install_root = root + "public/_components"
+	install_root = root + "public/_components"
 	
-	yarn_package_root.children.select(&:directory?).collect(&:basename).each do |package_directory|
-		install_path = yarn_install_root + package_directory
-		package_path = yarn_package_root + package_directory
+	package_root.children.select(&:directory?).collect(&:basename).each do |package_directory|
+		install_path = install_root + package_directory
+		package_path = package_root + package_directory
 		
 		dist_path = package_path + 'dist'
 		

data/lib/utopia/command.rb

@@ -28,8 +28,8 @@ require_relative 'command/environment'
 
 module Utopia
 	module Command
-		def self.call(*args)
-			Top.call(*args)
+		def self.call(*arguments)
+			Top.call(*arguments)
 		end
 		
 		# The top level utopia command.

data/lib/utopia/command/server.rb

@@ -68,7 +68,8 @@ module Utopia
 						system("git", "config", "receive.denyCurrentBranch", "ignore") or fail "could not set configuration"
 						system("git", "config", "core.worktree", destination_root) or fail "could not set configuration"
 						
-						system("bundle", "config", "set", "--local", "deployment", "true")
+						# Doing this invokes a lot of behaviour that isn't always ideal...
+						# system("bundle", "config", "set", "--local", "deployment", "true")
 						system("bundle", "config", "set", "--local", "without", "development")
 						
 						# In theory, to convert from non-shared to shared:

data/lib/utopia/command/site.rb

@@ -33,7 +33,7 @@ module Utopia
 		# Local site setup commands.
 		class Site < Samovar::Command
 			# Configuration files which should be installed/updated:
-			CONFIGURATION_FILES = ['.gitignore', 'config.ru', 'config/environment.rb', 'falcon.rb', 'Gemfile', 'Guardfile', 'bake.rb', 'spec/spec_helper.rb', 'spec/website_context.rb', 'spec/website_spec.rb']
+			CONFIGURATION_FILES = ['.gitignore', 'config.ru', 'config/environment.rb', 'falcon.rb', 'gems.rb', 'Guardfile', 'bake.rb', 'spec/spec_helper.rb', 'spec/website_context.rb', 'spec/website_spec.rb']
 			
 			# Directories that should exist:
 			DIRECTORIES = ["config", "lib", "pages", "public", "tasks", "spec"]
@@ -142,6 +142,15 @@ module Utopia
 					end
 				end
 				
+				# Move `Gemfile` to `gems.rb`.
+				def update_gemfile!
+					# If `Gemfile` doens't exist, we are done:
+					return unless File.exist?('Gemfile')
+					
+					system("git", "mv", "Gemfile", "gems.rb")
+					system("git", "mv", "Gemfile.lock", "gems.locked")
+				end
+				
 				def call
 					destination_root = parent.root
 					branch_name = "utopia-upgrade-#{Utopia::VERSION}"
@@ -184,6 +193,7 @@ module Utopia
 							system("git", "add", *Site::CONFIGURATION_FILES) or fail "could not add files"
 							
 							move_static!
+							update_gemfile!
 							
 							# Commit all changes:
 							system("git", "commit", "-m", "Upgrade to utopia #{Utopia::VERSION}.") or fail "could not commit changes"

data/lib/utopia/content.rb

@@ -177,17 +177,19 @@ module Utopia
 		end
 		
 		def content_tag(name, node)
-			parent_path = node.parent_path
+			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.
-			if name == node.name
-				parent_path = parent_path.dirname
+			while full_path.last == name
+				full_path.pop
 			end
 			
-			cache_key = parent_path + name
+			cache_key = full_path + name
 			
 			@node_cache.fetch_or_store(cache_key) do
-				lookup_content(name, parent_path)
+				lookup_content(name, full_path)
 			end
 		end
 	end

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

@@ -128,12 +128,12 @@ module Utopia
 			
 			# 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

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.

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