utopia 2.13.3 → 2.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6b3a2b969739fa3a580d3c52c8755a4603b51f4f8170358f36120cb746824764
-  data.tar.gz: 753825339c39b9e404dfe697254d8b5c56c1ae25750a81b23c89a72af5f6518b
+  metadata.gz: ddb5cc8a1bb593d344e0d2f2c8bf315704f297ae1e8063b4d7c0e5f3d71f4014
+  data.tar.gz: '09ff4febe6dd06945a3725e0c1354402e23bf837026c5aa09b6c2106b482e00d'
 SHA512:
-  metadata.gz: 2bae7423c0fc11004811f483219b64f73475b04865dbc95baed6ef7225c190eabdaeb72628c8e77c684393b35ba884640a35d6a916665259cb2881780098a0e6
-  data.tar.gz: 5b6074e3558a8e0e4efd0bb02ff09c1aaf01caade4b7d520dcbc3ac0041b678797ff06c32465aac51abed761cf1338db5ea712e8308e6448cd8a5c63ef0a9ce7
+  metadata.gz: 6a5a89b6bf438d72007dd8617085125aae4a038ee8267716361810e149f9488166323c299aea04baf69ebd54e630e20093c32ec8e016553b11ad46bfa54fe22c
+  data.tar.gz: bf6fcfe77a7423b39fabd019b40309c52db7a15284661243119d32c279d32d51d2467e4bff409cf6d53924baca9cc60d7788b00bbaf4f9986b65e2b0522e5dbd

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

@@ -5,12 +5,20 @@ def update
 	require 'fileutils'
 	require 'utopia/path'
 	
-	yarn_package_root = self.root + "lib/components"
-	yarn_install_root = self.root + "public/_components"
+	root = Pathname.new(context.root)
+	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'
 		
 		FileUtils::Verbose.rm_rf(install_path)

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

@@ -59,7 +59,7 @@ module Utopia
 			# The core namespace for utopia specific functionality:
 			@namespaces[UTOPIA_NAMESPACE] ||= Tags
 		end
-
+		
 		def freeze
 			return self if frozen?
 			
@@ -72,6 +72,7 @@ module Utopia
 		
 		attr :root
 		
+		# TODO we should remove this method and expose `@links` directly.
 		def links(path, **options)
 			@links.index(path, **options)
 		end
@@ -91,20 +92,23 @@ module Utopia
 			end
 		end
 		
-		# 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(request_path)
-			name = request_path.last
-			name_xnode = name.to_s + XNODE_EXTENSION
-
-			node_path = File.join(@root, request_path.dirname.components, name_xnode)
-
-			if File.exist? node_path
-				return Node.new(self, request_path.dirname + name, request_path, node_path)
+		# @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 path = link&.path
+				full_path = File.join(@root, path.dirname, link.key + XNODE_EXTENSION)
+				
+				if File.exist?(full_path)
+					return Node.new(self, path, path, full_path)
+				end
 			end
-
-			return nil
 		end
-
+		
 		def call(env)
 			request = Rack::Request.new(env)
 			path = Path.create(request.path_info)
@@ -112,17 +116,17 @@ module Utopia
 			# 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 link.path and node = lookup_node(link.path)
+				if node = resolve_link(link)
 					attributes = request.env.fetch(VARIABLES_KEY, {}).to_hash
 					
 					return node.process!(request, attributes)
@@ -153,14 +157,14 @@ module Utopia
 			
 			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

data/lib/utopia/content/link.rb

@@ -30,60 +30,55 @@ require_relative '../locale'
 
 module Utopia
 	class Content
-		INDEX = 'index'.freeze
-		
 		# Represents a link to some content with associated metadata.
 		class Link
-			def initialize(kind, path, info = nil)
-				path = Path.create(path)
-
-				@info = info || {}
+			# @param kind [Symbol] the kind of link.
+			def initialize(kind, name, locale, path, info, title = nil)
 				@kind = kind
-
-				case @kind
-				when :file
-					@name, @locale = path.last.split('.', 2)
-					@path = path
-				when :directory
-					@name = path.basename
-					
-					if @name == INDEX
-						@name = path.dirname.basename
-					end
-					
-					@locale = path.extension
-					@path = path
-				when :virtual
-					@name, @locale = path.to_s.split('.', 2)
-					@path = @info[:path] ? Path.create(@info[:path]) : nil
+				@name = name
+				@locale = locale
+				@path = Path.create(path)
+				@info = info || {}
+				@title = Trenni::Strings.to_title(title || name)
+			end
+			
+			def key
+				if locale
+					"#{@path.last}.#{@locale}"
 				else
-					raise ArgumentError.new("Unknown link kind #{@kind} with path #{path}")
+					@path.last
 				end
-				
-				@title = Trenni::Strings.to_title(@name)
 			end
-
+			
 			def href
 				@href ||= @info.fetch(:uri) do
 					(@path.dirname + @path.basename).to_s if @path
 				end
 			end
-
+			
 			# Look up from the `links.yaml` metadata with a given symbolic key.
 			def [] key
 				@info[key]
 			end
-
+			
 			attr :kind
 			attr :name
 			attr :path
 			attr :info
 			attr :locale
-
+			
 			def href?
 				!!href
 			end
-
+			
+			def index?
+				@kind == :index
+			end
+			
+			def virtual?
+				@kind == :virtual
+			end
+			
 			def relative_href(base = nil)
 				if base and href.start_with? '/'
 					Path.shortest_path(href, base)
@@ -91,11 +86,11 @@ module Utopia
 					href
 				end
 			end
-
+			
 			def title
 				@info.fetch(:title, @title)
 			end
-
+			
 			def to_anchor(base: nil, content: self.title, builder: nil, **attributes)
 				attributes[:class] ||= 'link'
 				
@@ -124,7 +119,7 @@ module Utopia
 			def eql? other
 				self.class.eql?(other.class) and kind.eql?(other.kind) and name.eql?(other.name) and path.eql?(other.path) and info.eql?(other.info)
 			end
-
+			
 			def == other
 				other and kind == other.kind and name == other.name and path == other.path
 			end

data/lib/utopia/content/links.rb

@@ -27,7 +27,8 @@ require 'concurrent/map'
 module Utopia
 	class Content
 		# The file extension for markup nodes on disk.
-		XNODE_EXTENSION = '.xnode'.freeze
+		XNODE_EXTENSION = '.xnode'
+		INDEX = "index"
 		
 		class Links
 			def self.for(root, path, locale = nil)
@@ -40,47 +41,55 @@ module Utopia
 				self.new(root).index(path, **options)
 			end
 			
-			XNODE_FILTER = /^(.+)#{Regexp.escape XNODE_EXTENSION}$/
-			INDEX_XNODE_FILTER = /^(index(\..+)*)#{Regexp.escape XNODE_EXTENSION}$/
-			
-			def initialize(root)
+			def initialize(root, extension: XNODE_EXTENSION)
 				@root = root
 				
-				@cache = Concurrent::Map.new
+				@extension = extension
+				@file_filter = /\A(?<key>(?<name>[^.]+)(\.(?<locale>.+))?)#{Regexp.escape extension}\Z/
+				@index_filter = /\A(?<key>(?<name>index)(\.(?<locale>.+))?)#{Regexp.escape extension}\Z/
+				
+				@metadata_cache = Concurrent::Map.new
+				@links_cache = Concurrent::Map.new
 			end
 			
+			attr :extension
+			attr :file_filter
+			attr :index_filter
+			
+			# Resolve a link for the specified path, which must be a path to a specific link.
+			# 	for(Path["/index"])
 			def for(path, locale = nil)
-				links = Resolved.new(self, path.dirname)
-				
-				links.lookup(path.last, locale)
+				links(path.dirname).lookup(path.last, locale)
 			end
 			
-			DEFAULT_INDEX_OPTIONS = {
-				:directories => true,
-				:files => true,
-				:virtuals => true,
-				:indices => false,
-				:sort => :order,
-				:display => :display,
-			}
-			
-			def index(path, **options)
-				options = DEFAULT_INDEX_OPTIONS.merge(options)
+			# Give an index of all links that can be reached from the given path.
+			def index(path, name: nil, locale: nil, display: :display, sort: :order, sort_default: 0, directories: true, files: true, virtuals: true, indices: false)
+				ordered = links(path).ordered.dup
+				
+				# Ignore specific kinds of links:
+				ignore = []
+				ignore << :directory unless directories
+				ignore << :file unless files
+				ignore << :virtual unless virtuals
+				ignore << :index unless indices
 				
-				ordered = Resolved.new(self, path, options).ordered
+				if ignore.any?
+					ordered.reject!{|link| ignore.include?(link.kind)}
+				end
 				
-				# This option filters a link based on the display parameter.
-				if display_key = options[:display]
-					ordered.reject!{|link| link.info[display_key] == false}
+				# Filter links by display key:
+				if display
+					ordered.reject!{|link| link.info[display] == false}
 				end
 				
-				# Named:
-				if name = options[:name]
+				# Filter links by name:
+				if name
 					# We use pattern === name, which matches either the whole string, or matches a regexp.
 					ordered.select!{|link| name === link.name}
 				end
 				
-				if locale = options[:locale]
+				# Filter by locale:
+				if locale
 					locales = {}
 					
 					ordered.each do |link|
@@ -94,10 +103,10 @@ module Utopia
 					ordered = locales.values
 				end
 				
-				# Sort:
-				if sort_key = options[:sort]
+				# Order by sort key:
+				if sort
 					# Sort by sort_key, otherwise by title.
-					ordered.sort_by!{|link| [link[sort_key] || options[:sort_default] || 0, link.title]}
+					ordered.sort_by!{|link| [link[sort] || sort_default, link.title]}
 				end
 				
 				return ordered
@@ -105,38 +114,65 @@ module Utopia
 			
 			attr :root
 			
-			# Represents a list of {Link} instances relating to the structure of the content. They are formed from the `links.yaml` file and the actual directory structure on disk.
-			class Resolved
-				DEFAULT_OPTIONS = {
-					:directories => true,
-					:files => true,
-					:virtuals => true,
-					:indices => true,
-				}
+			def metadata(path)
+				@metadata_cache.fetch_or_store(path.to_s) do
+					load_metadata(path)
+				end
+			end
+			
+			def links(path)
+				@links_cache.fetch_or_store(path.to_s) do
+					load_links(path)
+				end
+			end
+			
+			private
+			
+			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 }
+				end
 				
-				def initialize(links, top = Path.root, options = DEFAULT_OPTIONS)
+				return map
+			end
+			
+			LINKS_YAML = "links.yaml"
+			
+			def load_metadata(path)
+				yaml_path = File.join(path, LINKS_YAML)
+				
+				if File.exist?(yaml_path) && data = YAML::load_file(yaml_path)
+					return symbolize_keys(data)
+				else
+					return {}
+				end
+			end
+			
+			# Represents a list of {Link} instances relating to the structure of the content. They are formed from the `links.yaml` file and the actual directory structure on disk.
+			class Resolver
+				def initialize(links, top = Path.root)
 					raise ArgumentError.new("top path must be absolute") unless top.absolute?
 					
 					@links = links
 					
 					@top = top
-					@options = options
 					
 					# top.components.first == '', but this isn't a problem here.
 					@path = File.join(links.root, top.components)
 					
 					@ordered = []
-					@named = Hash.new{|h,k| h[k] = []}
+					@named = {}
 					
-					if File.directory? @path
+					if File.directory?(@path)
 						@metadata = links.metadata(@path)
 						
 						load_links(@metadata.dup) do |link|
 							@ordered << link
-							@named[link.name] << link
+							(@named[link.name] ||= []) << link
 						end
 					else
-						@metadata = {}
+						@metadata = nil
 					end
 				end
 				
@@ -144,6 +180,10 @@ module Utopia
 				attr :ordered
 				attr :named
 				
+				def indices
+					return @ordered.select{|link| link.index?}
+				end
+				
 				def each(locale)
 					return to_enum(:each, locale) unless block_given?
 					
@@ -155,115 +195,137 @@ module Utopia
 				def lookup(name, locale = nil)
 					# This allows generic links to serve any locale requested.
 					if links = @named[name]
-						links.find{|link| link.locale == locale} || links.find{|link| link.locale == nil}
+						generic_link = nil
+						
+						links.each do |link|
+							if link.locale == locale
+								return link
+							elsif link.locale.nil?
+								generic_link = link
+							end
+						end
+						
+						return generic_link
 					end
 				end
 				
 				private
 				
-				def indices(path, &block)
-					Dir.entries(path).select{|filename| filename.match(INDEX_XNODE_FILTER)}
+				def entries(path)
+					Dir.entries(path).reject{|entry| entry.match(/^[\._]/)}
 				end
 				
-				def load_indices(name, path, metadata)
-					directory_metadata = metadata.delete(name) || {}
-					indices_metadata = @links.metadata(path)
+				# @param name [String] the name of the directory.
+				def load_directory(name, metadata, &block)
+					defaults = metadata.delete(name) || {}
 					
-					indices_count = 0
+					links = @links.links(@top + name).indices
 					
-					indices(path).each do |filename|
-						index_name = File.basename(filename, XNODE_EXTENSION)
-						# Values in indices_metadata will override values in directory_metadata:
-						index_metadata = directory_metadata.merge(indices_metadata[index_name] || {})
-						
-						directory_link = Link.new(:directory, @top + [name, index_name], index_metadata)
-						
-						# Merge metadata from foo.en into foo/index.en
-						if directory_link.locale
-							localized_key = "#{directory_link.name}.#{directory_link.locale}"
-							if localized_metadata = metadata.delete(localized_key)
-								directory_link.info.update(localized_metadata)
-							end
+					links.each do |link|
+						# We extract the metadata according to the localized link:
+						if info = metadata.delete("#{name}.#{link.locale}")
+							info = info.merge(link.info)
+						else
+							info = link.info
 						end
 						
-						yield directory_link
-						
-						indices_count += 1
+						yield Link.new(:directory, name, link.locale, link.path, defaults.merge(info))
+					end
+				end
+				
+				def load_index(name, locale, info)
+					info ||=  {}
+					
+					if locale and defaults = @metadata[name]
+						info = defaults.merge(info)
 					end
 					
-					if indices_count == 0
-						# Specify a nil uri if no index could be found for the directory:
-						yield Link.new(:directory, top + [name], {:uri => nil}.merge(directory_metadata))
+					path = @top + name
+					
+					yield Link.new(:index, name, locale, path, info, path[-2])
+				end
+				
+				def load_default_index(name = INDEX, info = {})
+					path = @top + name
+					
+					if info
+						info = {uri: nil}.merge(info)
+					else
+						info = {uri: nil}
 					end
+					
+					# Specify a nil uri if no index could be found for the directory:
+					yield Link.new(:index, name, nil, @top, info, path[-2])
 				end
 				
-				def entries(path)
-					Dir.entries(path).reject{|filename| filename.match(/^[\._]/)}
+				def load_file(name, locale, info)
+					info ||= {}
+					
+					if locale and defaults = @metadata[name]
+						info = defaults.merge(info)
+					end
+					
+					path = @top + name
+					
+					yield Link.new(:file, name, locale, path, info)
 				end
 				
-				def load_links(metadata, &block)
-					# Load all metadata for a given path:
-					metadata = @metadata.dup
+				def load_virtuals(metadata)
+					virtuals = {}
 					
-					# Check all entries in the given directory:
-					entries(@path).each do |filename|
-						path = File.join(@path, filename)
+					# After processing all directory entries, we are left with virtual links:
+					metadata.each do |key, info|
+						name, locale = key.split('.', 2)
+						localized = (virtuals[name] ||= {})
+						localized[locale] = info
+					end
+					
+					virtuals.each do |name, localized|
+						defaults = localized[nil]
 						
-						# There are two types of filelinks based links:
-						# 1/ Named files, e.g. foo.xnode, name=foo
-						# 2/ Directories, e.g. bar/index.xnode, name=bar
-						if File.directory?(path) and @options[:directories]
-							load_indices(filename, path, metadata, &block)
-						elsif filename.match(INDEX_XNODE_FILTER) and @options[:indices] == false
-							metadata.delete($1) # We don't include indices in the list of pages.
-						elsif filename.match(XNODE_FILTER) and @options[:files]
-							yield Link.new(:file, @top + $1, metadata.delete($1))
+						localized.each do |locale, info|
+							info = defaults&.merge(info) || info
+							path = info[:path]
+							
+							yield Link.new(:virtual, name, locale, path, info)
 						end
 					end
+				end
+				
+				def load_links(metadata, &block)
+					index_loaded = false
 					
-					if @options[:virtuals]
-						# After processing all directory entries, we are left with virtual entries in the metadata:
-						metadata.each do |name, info|
-							virtual_link = Link.new(:virtual, name, info)
+					# Check all entries in the given directory:
+					entries(@path).each do |entry|
+						path = File.join(@path, entry)
+						
+						# There are serveral types of file based links:
+						
+						# 1. Directories, e.g. bar/ (name=bar)
+						if File.directory?(path)
+							load_directory(entry, metadata, &block)
 							
-							# Given a virtual named such as "welcome.cn", merge it with metadata from "welcome" if it exists:
-							if virtual_metadata = @metadata[virtual_link.name]
-								virtual_link.info.update(virtual_metadata)
-							end
+						# 2. Index files, e.g. index.xnode, name=parent
+						elsif match = entry.match(@links.index_filter)
+							load_index(match[:name], match[:locale], metadata.delete(match[:key]), &block)
+							index_loaded = true
 							
-							yield virtual_link
+						# 3. Named files, e.g. foo.xnode, name=foo
+						elsif match = entry.match(@links.file_filter)
+							load_file(match[:name], match[:locale], metadata.delete(match[:key]), &block)
 						end
 					end
+					
+					unless index_loaded
+						load_default_index(INDEX, metadata.delete(INDEX), &block)
+					end
+					
+					load_virtuals(metadata, &block)
 				end
 			end
 			
-			def metadata(path)
-				@cache.fetch_or_store(path.to_s) do
-					load(path).freeze
-				end
-			end
-			
-			private
-			
-			def symbolize_keys(hash)
-				# Second level attributes should be symbolic:
-				hash.each do |key, info|
-					hash[key] = info.each_with_object({}) { |(k,v),result| result[k.to_sym] = v }
-				end
-				
-				return hash
-			end
-			
-			LINKS_YAML = "links.yaml"
-			
-			def load(path)
-				yaml_path = File.join(path, LINKS_YAML)
-				
-				if File.exist?(yaml_path) && data = YAML::load_file(yaml_path)
-					return symbolize_keys(data)
-				else
-					return {}
-				end
+			def load_links(path)
+				Resolver.new(self, Path.create(path))
 			end
 		end
 	end