utopia 2.14.0 → 2.16.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a3a6b8f885af36532a896ea9ec0a781c2c9771e6a700a1387beaa6451de494cf
-  data.tar.gz: d67a5a7f1d2e4f83680b4216f10d2d52a9828021cddf08f3471e32a11465e513
+  metadata.gz: f1833aabc2d72234952e6ee164138d234cafc5d0d2015b64edcb28cead480c95
+  data.tar.gz: d6e9675b9921ae290547c25b11c8b5974860256393c65147705d0dd1472ba851
 SHA512:
-  metadata.gz: a5cdd9fda1b6eb6337948b89d6af6d5db3cbf74c74d767d3935612bf0015935e896f1ed1f3e350aa60b8d8af665c93a225df3f9aabbdb2ecd5eb41041c83b061
-  data.tar.gz: c731147ffd698996509a00b7502588975b7cf9fbb9abc9942fc1c93b0687b63c70c3f259e31ea343afe5fd79dfd98b5c299dbeca65997e0a0eaf929c2b7b904a
+  metadata.gz: cd8ee2bdd633f9bcd10be1bd18db664299e9cc8c16169ad7d84d934ba8abb301037d0a0f459608087204cd43ac51eb155e88c4af2e988d03b2c29859df5fc2a3
+  data.tar.gz: 4a16550958bc3ddf8fc37760f8436cc450d3e84ee2178ba6f194ce557869e0e20bfee0f3412eb6f2364c7f5ccc831da2b8f440fce11a81e8fc7f436914d64dde

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

@@ -6,12 +6,18 @@ def update
 	require 'utopia/path'
 	
 	root = Pathname.new(context.root)
-	yarn_package_root = root + "lib/components"
-	yarn_install_root = root + "public/_components"
+	package_root = root + "node_modules"
 	
-	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
+	# This is a legacy path:
+	unless package_root.directory?
+		package_root = root + "lib/components"
+	end
+	
+	install_root = root + "public/_components"
+	
+	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/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 = ['.yarnrc', '.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', 'Gemfile', '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"]

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

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

data/lib/utopia/middleware.rb

@@ -39,7 +39,7 @@ module Utopia
 	
 	# The same as {default_root} but returns an instance of {Path}.
 	# @return [Path] The path as requested.
-	def self.default_path(*args)
-		Path[default_root(*args)]
+	def self.default_path(*arguments)
+		Path[default_root(*arguments)]
 	end
 end